现在的位置: 首页 > 综合 > 正文

二叉树

2013年06月02日 ⁄ 综合 ⁄ 共 9648字 ⁄ 字号 小 中 大 ⁄ 评论关闭

1 递归写法：前序、中序、后序、90度旋转格式化打印二叉树用来熟悉递归算法与二叉树是怎么一回事，求叶子节点、求层数用来熟悉递归时候值传递（传递的值直接应用），值传递稍微有点不同的是用数组加空引用（比如String[] a = {"A","B","D",null,null,"E","G",null,null,null,"C","F"};）生成前序二叉树。

2 BST：排序二叉树，左最小根其次右最大，加入节点是一对一关系，所以每次从根节点开始循环就可生成，遍历时中序生成的就是排序好的。

3 二叉树非递归遍历：重点是保存本层现场和回退的时候要有标志指示代码从哪里开始继续执行。前序和中序因为访问根节点在右子树前，因此只要一个回退时是否访问左子树即可，也就是说进入右子树的时候没有保存根节点给本层的再次回退（保存也没有意义，因为访问本层之前做过了），并不是非常严格的栈实现递归算法。但后序一定要严格实现，同时保存根节点，同时得再加个标志位（之前访问了哪个节点）表示回退的时候是否访问右子树，也就是说2个标志，左是否进入（boolean型）和右是否进入（节点型存放之前访问过的一个节点）。

4吐槽的地方：java只能值传递，不能传地址，因此很多常规递归或者自实现递归遍历访问或者创建的时候，c++一般操作的是根节点，但java只能操作孩子节点，因为孩子节点的引用你传递下去是无意义的。由于值传递，不管下层孩子节点传到的引用怎么赋值，本层的孩子节点引用都是空。

代码：

[java]
view plaincopy
  1. package nuaa.ds;  
  2. //对于树来说，兄弟孩子表示法（还是二叉链表表示法）和二叉树的表示法一模一样  
  3. //左指针表示孩子，右指针表示兄弟  
  4. /** 
  5.  * 二叉树重要的是递归思路，自身发生一些行为，然后调用自身函数传递不同参数，意味着跑到 
  6.  *其他点上做相同的行为 
  7.  * 实际上二叉树遍历过程就是左节点一路到底，然后回退看是否存在右节点，访问代码位置的 
  8.  * 不同产生了所谓的pre inorder post 
  9.  */  
  10. public class BinaryTree<T> {  
  11.       
  12.     private Node<T> root;  
  13.   
  14.     public void traversal(VisitOrder order){  
  15.         switch(order){//switch语法和枚举是绝配  
  16.         case DLR:  
  17.             preTraversal(this.root);  
  18.             break;  
  19.         case LDR:  
  20.             inorderTraversal(this.root);  
  21.             break;  
  22.         case LRD:  
  23.             postTraversal(this.root);  
  24.         }  
  25.           
  26.     }  
  27.       
  28.     private void postTraversal(Node<T> root){  
  29.         if(root.left!=null){  
  30.             postTraversal(root.left);  
  31.         }  
  32.         if(null!=root.right){  
  33.             postTraversal(root.right);  
  34.         }  
  35.         visit(root);  
  36.     }  
  37.     private void inorderTraversal(Node<T> root){  
  38.         if(root.left!=null){  
  39.             inorderTraversal(root.left);  
  40.         }  
  41.         visit(root);  
  42.         if(root.right!=null){  
  43.             inorderTraversal(root.right);  
  44.         }  
  45.     }  
  46.     private void preTraversal(Node<T> root){  
  47.         visit(root);  
  48.         if(root.left!=null){  
  49.             preTraversal(root.left);  
  50.         }  
  51.         if(root.right!=null){  
  52.             preTraversal(root.right);  
  53.         }  
  54.     }  
  55.       
  56.     /** 
  57.      * visit函数从外部使用接口定义， 
  58.      * 作为函子传递进来更合适。类似于排序的Comparator函子 
  59.      * 这里简单起见 
  60.      */  
  61.     private void visit(Node<T> root){  
  62.         System.out.println(root.data);  
  63.     }  
  64.       
  65.       
  66.     //求叶子节点个数  
  67.     public int getLeafNumber(){  
  68.         return getLeafNumber(this.root);  
  69.     }  
  70.     private int getLeafNumber(Node<T> root){  
  71.         if(root==null){  
  72.             return 0;  
  73.         }  
  74.         if(root.left==null&&root.right==null){  
  75.             return 1;  
  76.         }  
  77.         int leftNumber = getLeafNumber(root.left);  
  78.         int rightNumber = getLeafNumber(root.right);  
  79.         return leftNumber+rightNumber;  
  80.     }  
  81.       
  82.     //求树的层数,层数从1开始表示  
  83.     public int getLayerNumber(){  
  84.         return this.getLayerNumber(this.root);  
  85.     }  
  86.     private int getLayerNumber(Node<T> root){  
  87.         if(root==null){  
  88.             return 0;  
  89.         }  
  90.         if(root.left==null&&root.right==null){  
  91.             return 1;  
  92.         }  
  93.         int leftLayerNumber = getLayerNumber(root.left);  
  94.         int rightLayerNumber = getLayerNumber(root.right);  
  95.         return (leftLayerNumber > rightLayerNumber?  
  96.                                     leftLayerNumber:rightLayerNumber)+1;   
  97.     }  
  98.       
  99.     //建立排序二叉树  
  100.     public void createBSTbyArray(T[] t,Comparator<T> c){  
  101.         if(t==null||t.length==0){  
  102.             throw new IllegalArgumentException("数组长度不能为0");  
  103.         }  
  104.           
  105.         int index = 1;//数组的索引  
  106.         this.root = new Node<T>(t[0]);//保存根节点  
  107.         boolean left = true;//新插入的元素是否放左子树的标志位  
  108.         Node<T> iterator = root;//二叉树迭代元素标志  
  109.         while(index<t.length){  
  110.             while(true){  
  111.                 if(c.compare(iterator.data, t[index])<0){  
  112.                     if(iterator.left!=null){  
  113.                         iterator = iterator.left;  
  114.                     }  
  115.                     else{  
  116.                         break;  
  117.                     }  
  118.                 }else{  
  119.                     if(iterator.right!=null){  
  120.                         iterator = iterator.right;  
  121.                     }  
  122.                     else{  
  123.                         left = false;  
  124.                         break;  
  125.                     }  
  126.                 }  
  127.             }  
  128.             if(left){  
  129.                 iterator.left = new Node<T>(t[index]);  
  130.             }else{  
  131.                 iterator.right = new Node<T>(t[index]);  
  132.             }  
  133.             index++;  
  134.             iterator = root;  
  135.             left = true;  
  136.         }  
  137.   
  138.               
  139.     }  
  140.       
  141.     /** 
  142.      * 格式化打印二叉树,递归特性导致竖的直接打印不了， 
  143.      * 必须存个数组保存对应序号再打印数组才能实现。 
  144.      * 所以就打印个旋转90度的，采用逆中序 
  145.      * 其实打印下来还是很丑。。只能看出个大概，根据层数判断谁连谁。。。 
  146.      */  
  147.     public void printTree(){  
  148.         printTree(this.root,1);  
  149.           
  150.     }  
  151.     private void printTree(Node<T> root,int layerNumber){  
  152.         if(null!=root.right){  
  153.             this.printTree(root.right, layerNumber+1);  
  154.         }  
  155.           
  156.         for(int i=1;i<layerNumber;i++){  
  157.             System.out.print(" ");  
  158.         }  
  159.         this.visit(root);  
  160.         if(null!=root.left){  
  161.             this.printTree(root.left, layerNumber+1);  
  162.         }  
  163.           
  164.     }  
  165.       
  166.     //自建堆栈遍历二叉树  
  167.     public void traversalUsingStack(VisitOrder order){  
  168.         switch(order){  
  169.         case DLR:  
  170.             preTraversalUsingStack();  
  171.             break;  
  172.         case LRD:  
  173.             postTraversalUsingStack();  
  174.             break;  
  175.         case LDR:  
  176.             inorderTraversalUsingStack();  
  177.         }  
  178.     }  
  179.       
  180.     //思路大于代码，想清楚递归过程更重要。  
  181.     private void preTraversalUsingStack(){  
  182.         if(this.root==null){  
  183.             System.out.println("二叉树为空");  
  184.             return;  
  185.         }     
  186.         Stack<Node<T>> stack = new Stack<Node<T>>();  
  187.         Node<T> iterator  = this.root;//迭代因子  
  188.         stack.push(iterator);//这个只是为了满足循环条件  
  189.         boolean left = true;//是否访问左子树（标记位，表示从上层的哪里继续访问）  
  190.           
  191.         while(!stack.isEmpty()){//遍历到最后重复放置的根时正好为空跳出循环  
  192.             while(left){//当左子树存在的时候并且应该访问左子树  
  193.                 visit(iterator);//首先访问根节点  
  194.                 if(iterator.left!=null){//左子树存在的话  
  195.                     stack.push(iterator);//保留现场也就是存放根  
  196.                     iterator = iterator.left;//等于递归调用自身，左子树的根作为新的参数  
  197.                 }else{  
  198.                     break;//左子树访问到底了等于第一个递归调用自身结束了就跳出来  
  199.                 }  
  200.             }  
  201.               
  202.             if(iterator.right!=null){//当前节点存在右子树  
  203.                 iterator = iterator.right;//由右子树开始进入新一层的递归调用  
  204.                 left = true;  
  205.             }else{  
  206.                 iterator = stack.pop();//一直回退，直到找到  
  207.                 left = false;//回退过程中不访问左子树，一直查找对应的根节点  
  208.             }                //是否存在右子树  
  209.         }  
  210.     }  
  211.   
  212.     private void postTraversalUsingStack(){  
  213.         if(this.root==null){  
  214.             System.out.println("二叉树为空");  
  215.             return;  
  216.         }  
  217.         Node<T> iterator = this.root;  
  218.         Node<T> previous = null;  
  219.         Stack<Node<T>> stack = new Stack<Node<T>>();  
  220.         stack.push(iterator);  
  221.         boolean left = true;  
  222.         while(!stack.isEmpty()){  
  223.             while(iterator.left!=null&&left){  
  224.                 stack.push(iterator);  
  225.                 iterator = iterator.left;  
  226.             }  
  227.             if(iterator.right!=null&&(previous==null||!previous.equals(iterator.right))){  
  228.                 stack.push(iterator);  
  229.                 iterator = iterator.right;  
  230.                 left = true;  
  231.             }else{  
  232.                   
  233.                 visit(iterator);  
  234.                 previous = iterator;  
  235.                 iterator = stack.pop();  
  236.                 left = false;  
  237.                   
  238.             }  
  239.         }  
  240.     }  
  241.     private void inorderTraversalUsingStack(){  
  242.         if(this.root==null){  
  243.             System.out.println("二叉树为空");  
  244.             return;  
  245.         }  
  246.         Node<T> iterator = this.root;  
  247.         Stack<Node<T>> stack = new Stack<Node<T>>();  
  248.         stack.push(iterator);//实际编程的trick，正好满足循环条件  
  249.         boolean left = true;  
  250.         while(!stack.isEmpty()){//多入栈的根节点出栈时候正好循环终止  
  251.             while(iterator.left!=null&&left){  
  252.                 stack.push(iterator);  
  253.                 iterator = iterator.left;  
  254.             }  
  255.             visit(iterator);  
  256.             if(iterator.right!=null){//右子树存在  
  257.                 iterator = iterator.right;//右孩子作为根进入下层递归  
  258.                 left = true;  
  259.             }else{//右孩子不存在  
  260.                 iterator = stack.pop();//返回上层  
  261.                 left = false;  
  262.             }  
  263.         }  
  264.     }  
  265.       
  266.     //这函数意义其实不大,数组本身可以根据下标当成二叉树，练习而已  
  267.     //c在本层创建根节点，java在本层创建孩子节点  
  268.     public void createBTbyArray(T[] t,VisitOrder order){  
  269.         if(t.length==0){  
  270.             throw new IllegalArgumentException("数组为空");  
  271.         }  
  272.         switch(order){  
  273.         case DLR:  
  274.             this.root = new Node<T>(t[0]);//保留根  
  275.             preCreateByArray(t,1,this.root);  
  276.             break;  
  277.         case LDR:     
  278.         case LRD:  
  279.             throw new IllegalArgumentException("中序和后序无法根据数组确定二叉树");  
  280.         }  
  281.     }  
  282.     private int preCreateByArray(T[] t,int index,Node<T> root){  
  283.           
  284.         if(index<t.length&&null!=t[index]){  
  285.             root.left = new Node<T>(t[index]);  
  286.             index = preCreateByArray(t,index+1,root.left);  
  287.         }  
  288.         index = index+1;  
  289.         if(index<t.length&&null!=t[index]){  
  290.             root.right = new Node<T>(t[index]);  
  291.             index = preCreateByArray(t,index+1,root.right);  
  292.         }  
  293.         return index;     
  294.     }  
  295.       
  296.       
  297.     private class Node<U>{  
  298.         private U data;  
  299.         private Node<U> left;  
  300.         private Node<U> right;  
  301.           
  302.         //构造函数初始化内存，无需泛型  
  303.         //只有类泛型和函数泛型  
  304.         public Node(U t){  
  305.             this.data=t;  
  306.         }  
  307.           
  308.     }  
  309. }  

盲点：BST的平衡、加权二叉树典型应用比如哈夫曼，用数组表示，长的不像二叉树了，还没写。

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞