树

1.为什么需要树这种数据结构

1.1 数组存储方式分析

　　ArrayList底层数组扩容方法：

2.树

2.2 二叉树

　　如果用二叉树来存储数据，那么对数据的增删改查的效率都可以得到保障。

2.2.1 二叉树的概念

2.2.2 二叉树的遍历

（1）前序遍历

　　a. 先输出当前节点（初始的时候是root节点）；

　　b. 如果左子节点不为空，则递归继续前序遍历；

　　c. 如果右子节点不为空，则递归继续前序遍历

（2）中序遍历

　　a. 如果当前节点的左子节点不为空，则递归继续中序遍历；

　　b. 输出当前节点；

　　c. 如果当前节点的右子节点不为空，则递归继续中序遍历；

（3）后序遍历

　　a. 如果当前节点的左子节点不为空，则递归继续后序遍历；

　　b. 如果当前节点的右子节点不为空，则递归继续后序遍历；

　　c. 输出当前节点

  1 package Tree;
  2 
  3 public class BinaryTreeDemo {
  4     
  5     public static void main(String[] args){
  6         BinaryTree bt=new BinaryTree();
  7         Node n1=new Node(1,"宋江");
  8         Node n2=new Node(2,"卢俊义");
  9         Node n3=new Node(3,"吴用");
 10         Node n4=new Node(4,"林冲");
 11         
 12         bt.root=n1;
 13         n1.left=n2;
 14         n1.right=n3;
 15         n3.right=n4;
 16         
 17         
 18         System.out.println("-------------");
 19         System.out.println("前序遍历:");
 20         bt.preOrder();
 21         System.out.println("************");
 22         System.out.println("中序遍历:");
 23         bt.infixOrder();
 24         System.out.println("************");
 25         System.out.println("后序遍历:");
 26         bt.postOrder();
 27         System.out.println("-------------");
 28         
 29         
 30         
 31         bt.preSearch(3);
 32         
 33         bt.infixSearch(0);
 34         
 35         bt.postSearch(6);
 36         
 37     }
 38 
 39 }
 40 
 41 class Node{
 42     int no;
 43     String name;
 44     Node left;
 45     Node right;
 46     @Override
 47     public String toString() {
 48         return "编号: " + no + "  姓名: " + name ;
 49     }
 50     public Node(int no, String name) {
 51         super();
 52         this.no = no;
 53         this.name = name;
 54     }
 55     
 56     
 57     //前序遍历
 58     public void preOrder(){
 59         System.out.println(this);
 60         if(this.left!=null){
 61             this.left.preOrder();
 62         }
 63         if(this.right!=null){
 64             this.right.preOrder();
 65         }
 66     }
 67     
 68     
 69     //中序遍历
 70     public void infixOrder(){
 71         if(this.left!=null){
 72             this.left.infixOrder();
 73         }
 74         
 75         System.out.println(this);
 76         
 77         if(this.right!=null){
 78             this.right.infixOrder();
 79         }
 80     }
 81     
 82     //后序遍历
 83     public void postOrder(){
 84         if(this.left!=null){
 85             this.left.postOrder();
 86         }
 87         if(this.right!=null){
 88             this.right.postOrder();
 89         }
 90         System.out.println(this);
 91     }
 92     
 93     
 94     /*
 95     //前序查找
 96     public Node preSearch(int no){
 97         if(this.no==no){
 98             return this;
 99         }else{
100             if(this.left!=null){
101                 this.left.preSearch(no);
102             }
103             if(this.right!=null){
104                 this.right.preSearch(no);
105             }
106         }
107         return null;
108     }
109     
110     */
111     
112     //前序查找
113         public Node preSearch(int no){
114             
115             System.out.println(this);//打印查找步骤
116             if(this.no==no){
117                 return this;
118                }
119             Node result=null;
120             
121             if(this.left!=null){
122                 result=this.left.preSearch(no);
123             }
124             
125             if(result!=null){
126                 return result;
127             }
128             
129             if(this.right!=null){
130                 result=this.right.preSearch(no);
131             }
132             
133             if(result!=null){
134                 return result;
135             }
136             return result;
137     }
138         
139         
140         //中序查找
141         public Node infixSearch(int no){
142             Node result=null;
143             if(this.left!=null){
144                 //System.out.println(this.left);
145                 result=this.left.infixSearch(no);
146             }
147             
148             if(result!=null){
149                 return result;
150             }
151             
152             System.out.println(this);//打印查找步骤
153             if(this.no==no){
154                 return result=this;
155             }
156             
157             if(this.right!=null){
158                 result=this.right.infixSearch(no);
159             }
160             return result;
161             
162             
163         }
164         
165         //后序查找
166         public Node postSearch(int no){
167             Node result=null;
168             if(this.left!=null){
169                 result=this.left.postSearch(no);
170             }
171             
172             if(result!=null){
173                 return result;
174             }
175             
176             
177             if(this.right!=null){
178                 result=this.right.postSearch(no);
179             }
180             
181             if(result!=null){
182                 return result;
183             }
184             
185             
186             System.out.println(this);//打印查找步骤
187             if(this.no==no){
188                 return result=this;
189             }
190             
191             return result;
192         }
193         
194     
195 }
196 
197 class BinaryTree{
198     Node root;
199     
200     //前序遍历
201     public void preOrder(){
202         if(this.root!=null){
203             this.root.preOrder();
204         }else{
205             System.out.println("此树为空!!!");
206         }
207     }
208     
209     
210     //中序遍历
211     public void infixOrder(){
212         if(this.root!=null){
213             this.root.infixOrder();
214         }else{
215             System.out.println("此树为空!!!");
216         }
217     }
218     
219     
220     //后序遍历
221         public void postOrder(){
222             if(this.root!=null){
223                 this.root.postOrder();
224             }else{
225                 System.out.println("此树为空!!!");
226             }
227         }
228         
229         
230     //前序查找
231         public void preSearch(int no){
232             if(this.root!=null){
233                 Node result=this.root.preSearch(no);
234                 if(result!=null){
235                     System.out.println("已找到: ");
236                     System.out.println(result);
237                 }else{
238                     System.out.println("未找到信息");
239                 }
240             }else{
241               System.out.println("此树为空!!!");
242             }
243         }
244         
245         
246         //中序查找
247         public void infixSearch(int no){
248             if(this.root!=null){
249                 Node result=this.root.infixSearch(no);
250                 if(result!=null){
251                     System.out.println("已找到: ");
252                     System.out.println(result);
253                 }else{
254                     System.out.println("未找到信息");
255                 }
256             }else{
257               System.out.println("此树为空!!!");
258             }
259         }
260         
261         //后序查找
262                 public void postSearch(int no){
263                     if(this.root!=null){
264                         Node result=this.root.postSearch(no);
265                         if(result!=null){
266                             System.out.println("已找到: ");
267                             System.out.println(result);
268                         }else{
269                             System.out.println("未找到信息");
270                         }
271                     }else{
272                       System.out.println("此树为空!!!");
273                     }
274                 }
275 }

 2.2.3 二叉树删除节点：

 1 class Node{
 2     int no;
 3     String name;
 4     Node left;
 5     Node right;
 6     @Override
 7     public String toString() {
 8         return "编号: " + no + "  姓名: " + name ;
 9     }
10     public Node(int no, String name) {
11         super();
12         this.no = no;
13         this.name = name;
14     }
15     
16         
17         //删除
18         public void delete(int no){
19             if(this.left!=null&&this.left.no==no ){
20                 this.left=null;
21                 return;
22             }
23             
24             if(this.left!=null){
25                 this.left.delete(no);
26             }
27             
28             if(this.right!=null&&this.right.no==no){
29                 this.right=null;
30                 return;
31             }
32             
33             if(this.right!=null){
34                 this.right.delete(no);
35             }
36             
37         }
38         
39         
40         
41     
42 }
 1 class BinaryTree{
 2     Node root;
 3 
 4         //删除
 5     public void delete(int no){
 6       if(this.root==null){
 7         System.out.println("此树为空!!!");
 8       }else{
 9         if(this.root.no==no){
10                 this.root=null;
11             System.out.println("删除成功!!!");
12         }else{
13                 this.root.delete(no);
14             }
15         }
16     }
17 }

2.2.4二叉树顺序存储

（1）顺序存储二叉树的概念

（2）顺序存储二叉树的特点

（3）代码实现

要求：给一个数组{1，2，3，4，5，6，7}，要求以二叉树前序、中序、后序遍历的方式分别进行遍历

  1 package Tree;
  2 
  3 public class ArrBinaryTreeDemo {
  4 
  5     public static void main(String[] args){
  6     
  7     int[] arr={1,2,3,4,5,6,7};
  8     ArrBinaryTree abt=new ArrBinaryTree(arr);
  9     
 10     System.out.print("原始数列:");
 11     for(int a:arr){
 12         System.out.print(a+" ");
 13     }
 14     System.out.println();
 15     System.out.print("前序遍历:");
 16     abt.preOrder();
 17     System.out.println();
 18     System.out.print("中序遍历:");
 19     abt.infixOrder();
 20     System.out.println();
 21     System.out.print("后序遍历:");
 22     abt.postOrder();
 23     
 24  }
 25 }
 26 
 27 class ArrBinaryTree{
 28     int[] arr;
 29 
 30     public ArrBinaryTree(int[] arr) {
 31         this.arr = arr;
 32     }
 33     
 34     
 35     //方法重载
 36     public void preOrder(){
 37         preOrder(0);
 38     }
 39     
 40     public void infixOrder(){
 41         infixOrder(0);
 42     }
 43     
 44     public void postOrder(){
 45         postOrder(0);
 46     }
 47     
 48     //顺序存储二叉树的前序遍历
 49     public void preOrder(int index){
 50         if(arr==null||arr.length==0){
 51             System.out.println("数组为空!!!");
 52         }else{
 53             System.out.print(arr[index]+" ");
 54             
 55             //向左递归遍历
 56             if((index*2+1)<arr.length){
 57                 preOrder(2*index+1);
 58             }
 59             
 60             //向右递归遍历
 61             if((index*2+2)<arr.length){
 62                 preOrder(2*index+2);
 63             }
 64         }
 65     }
 66     
 67     
 68     //顺序存储二叉树的中序遍历
 69     public void infixOrder(int index){
 70         if(arr==null||arr.length==0){
 71             System.out.println("数组为空!!!");
 72         }else{
 73             if((index*2+1)<arr.length){
 74                 infixOrder(index*2+1);
 75             }
 76             
 77             System.out.print(arr[index]+" ");
 78             
 79             if((index*2+2)<arr.length){
 80                 infixOrder(index*2+2);
 81             }
 82         }
 83     }
 84     
 85     
 86     
 87     //顺序存储二叉树的后序遍历
 88     public void postOrder(int index){
 89         if(arr==null||arr.length==0){
 90             System.out.println("数组为空!!!");
 91         }else{
 92             if((index*2+1)<arr.length){
 93                 postOrder(index*2+1);
 94             }
 95             
 96             if((index*2+2)<arr.length){
 97                 postOrder(index*2+2);
 98             }
 99             
100             System.out.print(arr[index]+" ");
101         }
102     }
103 }

运行结果：

 2.2.5 线索化二叉树

（1）提出

 

（2）线索二叉树基本介绍

（3）例子

a.案例

b. 思路分析

 

posted @ 2021-03-10 13:58  L1998  阅读(51)  评论(0)    收藏  举报