1、二叉树的建立
首先,定义数组存储树的data,然后使用list集合将所有的二叉树结点都包含进去,最后给每个父亲结点赋予左右孩子。
需要注意的是:最后一个父亲结点需要单独处理
1 public staticTreeNode root;2 //建立二叉树内部类
3 classTreeNode{4 public Object data; //携带变量
5 public TreeNode lchild,rchild; //左右孩子
6 publicTreeNode() {7 data = null;8 lchild = null;9 rchild = null;10 }11 publicTreeNode(Object data) {12 this.data =data;13 }14 public voidsetLeft(TreeNode left)15 {16 this.lchild =left;17 }18 public voidsetRight(TreeNode right)19 {20 this.rchild =right;21 }22 }23 //建立二叉树,通过List作为中间过渡量
24 public void CreatBinTree(int []datas,Listnodelist) {25 for(int i=0;i
31 for(int index = 0;index
34 nodelist.get(index).lchild = nodelist.get(2*index+1);35 nodelist.get(index).rchild = nodelist.get(2*index+2);36 }37 //单独处理最后一个父亲结点
38 int index = nodelist.size()/2-1;39 nodelist.get(index).lchild = nodelist.get(2*index+1);40 if(nodelist.size()%2==1)41 nodelist.get(index).rchild = nodelist.get(2*index+2);42 }
2、先序遍历
2.1 递归方法
//先序遍历,递归操作
public voidPreOrder(TreeNode root)
{if(root == null)return;
System.out.print(root.data+" ");
PreOrder(root.lchild);
PreOrder(root.rchild);
}
2.2 非递归操作,使用栈(两种方法)
本人认为第一种方法相对容易理解,较为简单
方法一:
思想:
(1)若栈非空或者结点非空,则进入循环
(2)若结点非空,读取该节点,并将结点压入栈中,结点向左孩子移动,移到最左孩子
(3)若栈非空,取出栈顶元素,此时父节点已读,所以移向右孩子
****************核心为:边读取左结点变将其压入栈中,左孩子对下一级来说上也代表父亲结点,所以之后可以直接读取右孩子。*******************
/** 方法一:先序遍历,使用栈操作,相对较简单
* 思想:
* (1)若栈非空或者结点非空,则进入循环
* (2)若结点非空,读取该节点,并将结点压入栈中,结点向左孩子移动,移到最左孩子
* (3)若栈非空,取出栈顶元素,此时父节点已读,所以移向右孩子
* 核心为:边读取左结点变将其压入栈中,左孩子对下一级来说上也代表父亲结点,所以之后可以直接读取右孩子。*/
public voidpreOrder1()
{
Stack stack = new Stack<>();
TreeNode node=root;while(!stack.isEmpty()||node!=null)
{while(node!=null)
{
System.out.print(node.data+" "); //访问该节点
stack.push(node);
node=node.lchild;
}if(!stack.isEmpty())
{
node=stack.pop();
node=node.rchild;
}
}
}
方法二:
思想:
(1)首先将根节点入栈
(2)判断非空,将结点从栈中取出并访问
(3)依次访问栈中的左孩子,并将右孩子放入栈中,结点不断往左孩子移动
(4)重复步骤(2)(3),直到栈为空
/** 方法二:先序遍历,使用栈操作,相对较麻烦
* 思想:
* (1)首先将根节点入栈
* (2)判断非空,将结点从栈中取出并访问
* (3)依次访问栈中的左孩子,并将右孩子放入栈中,结点不断往左孩子移动
* (4)重复步骤(2)(3),直到栈为空*/
public void preOrder2() throwsException
{
TreeNode pNode=root;if(pNode!=null) //首先判断根结点是否为空
{
Stack astack = new Stack<>(); //构造栈操作
astack.push(pNode); //将根节点压入栈中
while(!astack.isEmpty()) //循环操作直到栈中没有结点存在,即最右结点访问完毕
{
pNode= astack.pop(); //首先将结点从栈中取出
System.out.print(pNode.data+" "); //访问该节点
while(pNode!=null) //若该结点不为空
{if(pNode.lchild!=null) //访问左子树
System.out.print(pNode.lchild.data+" ");if(pNode.rchild!=null) //将右子树压入栈中
astack.push(pNode.rchild);
pNode= pNode.lchild; //进入到下一个左子树中
}
}
}
}
3、中序遍历
3.1 递归操作
//中序遍历,递归操作
public voidinOrder(TreeNode root)
{if(root==null)return;
inOrder(root.lchild);
System.out.print(root.data+" ");
inOrder(root.rchild);
}
3.2 非递归操作,栈
思想:
* (1)若栈非空或者结点非空,则进入循环
* (2)若结点非空,则将结点压入栈中,结点向左孩子移动,一直到最左边
* (3)若栈非空,则取出栈顶元素,并读取访问数据,而后结点向右孩子移动
/** 中序遍历,使用栈操作
* 思想:
* (1)若栈非空或者结点非空,则进入循环
* (2)若结点非空,则将结点压入栈中,结点向左孩子移动,一直到最左边
* (3)若栈非空,则取出栈顶元素,并读取访问数据,而后结点向右孩子移动*/
public void inOrder1() throwsException
{
TreeNode node=root;
Stack stack = new Stack<>();while(node!=null||!stack.isEmpty())
{while(node!=null)
{
stack.push(node);
node=node.lchild;
}if(stack!=null)
{
node=stack.pop();
System.out.print(node.data+" ");
node=node.rchild;
}
}
}
4、后序遍历
4.1 递归操作
//后序遍历,递归操作
public voidpostOrder(TreeNode root)
{if(root==null)return;
postOrder(root.lchild);
postOrder(root.rchild);
System.out.print(root.data+" ");
}
4.2 非递归操作
前提:设置标志结点pre,指示是否访问过某结点
思想:
* (1)若栈非空或者结点非空,则进入循环
* (2)若结点非空,则将结点压入栈中,结点向左孩子移动,一直到最左边
* (3)若栈非空,首先取出栈顶元素的右孩子赋给tmp
1、若栈顶元素的右孩子为空或者等于pre(即已访问过),则弹出元素并访问,将该结点赋值给pre,并将当前结点赋值为null
2、否则的话将右孩子赋值给当前结点
/** 后序遍历,栈操作
* 前提:设置标志结点pre,指示是否访问过某结点
* 思想:
* (1)若栈非空或者结点非空,则进入循环
* (2)若结点非空,则将结点压入栈中,结点向左孩子移动,一直到最左边
* (3)若栈非空,首先取出栈顶元素的右孩子赋给tmp
* 1、若栈顶元素的右孩子为空或者等于pre(即已访问过),则弹出元素并访问,将该结点赋值给pre,并将当前结点赋值为null
* 2、否则的话将右孩子赋值给当前结点*/
public voidpostOrder1()
{
Stack stack = new Stack<>();
TreeNode node= root,pre =root;while(!stack.isEmpty()||node!=null)
{while(node!=null)
{
stack.push(node);
node=node.lchild;
}if(!stack.isEmpty())
{
TreeNode tmp=stack.peek().rchild;if(tmp==null||tmp==pre)
{
node=stack.pop();
System.out.print(node.data+" ");
pre=node;
node= null;
}else{
node=tmp;
}
}
}
}
5、层次遍历(广度优先遍历)使用队列
思想:
* (1)读取根节点,并将其压入队列中
* (2)以队列的长度作为循环的判断条件,取出队收元素并访问,访问后将其弹出
* (3)判断是否有左右孩子,若有则加入队列中。
public voidbfs()
{
Queue queue = newLinkedList();if(root==null)return;
queue.offer(root);while(queue.size()>0) {
TreeNode node=queue.peek();
queue.poll();
System.out.print(node.data+" ");if(node.lchild!=null)
{
queue.offer(node.lchild);
}if(node.rchild!=null)
{
queue.offer(node.rchild);
}
}
}
6、深度优先遍历
此部分相对较难理解,自行琢磨
public void dfs(TreeNode node,List> nList,Listlist)
{if(node==null)return;if(node.lchild==null&node.rchild==null)
{
list.add((Integer) node.data);
nList.add(new ArrayList<>(list));
list.remove(list.size()-1);
}
list.add((Integer) node.data);
dfs(node.lchild, nList, list);
dfs(node.rchild, nList, list);
list.remove(list.size()-1);
}
7、求树的深度
(1)若二叉树为空,则返回0
(2)若二叉树非空,求左子树的深度,求右子树的深度
(3)比较左右子树的深度,求最大值加1,即为二叉树的深度
//求二叉树的深度
public intDepth(TreeNode node)
{if(node==null)return 0;else{int ldepth =Depth(node.lchild);
System.out.println("node'data:"+node.data+"ldepth: "+ldepth);int rdepth =Depth(node.rchild);
System.out.println("node'data:"+node.data+"rdepth: "+rdepth+" ");if(ldepth
return ldepth+1;
}
}
7、应用及全部代码展示
1 packageMain;2
3 importjava.util.ArrayList;4 importjava.util.Collection;5 importjava.util.Iterator;6 importjava.util.LinkedList;7 importjava.util.List;8 importjava.util.Queue;9 importjava.util.Scanner;10 importjava.util.Stack;11
12 importjavax.naming.directory.SearchControls;13 public classMain{14 public staticTreeNode root;15 //建立二叉树内部类
16 classTreeNode{17 public Object data; //携带变量
18 public TreeNode lchild,rchild; //左右孩子
19 publicTreeNode() {20 data = null;21 lchild = null;22 rchild = null;23 }24 publicTreeNode(Object data) {25 this.data =data;26 }27 public voidsetLeft(TreeNode left)28 {29 this.lchild =left;30 }31 public voidsetRight(TreeNode right)32 {33 this.rchild =right;34 }35 }36 //建立二叉树,通过List作为中间过渡量
37 public void CreatBinTree(int []datas,Listnodelist) {38 for(int i=0;i
44 for(int index = 0;index
47 nodelist.get(index).lchild = nodelist.get(2*index+1);48 nodelist.get(index).rchild = nodelist.get(2*index+2);49 }50 //单独处理最后一个父亲结点
51 int index = nodelist.size()/2-1;52 nodelist.get(index).lchild = nodelist.get(2*index+1);53 if(nodelist.size()%2==1)54 nodelist.get(index).rchild = nodelist.get(2*index+2);55 }56 //先序遍历,递归操作
57 public voidPreOrder(TreeNode root)58 {59 if(root == null)60 return;61 System.out.print(root.data+" ");62 PreOrder(root.lchild);63 PreOrder(root.rchild);64 }65 /*
66 * 方法一:先序遍历,使用栈操作,相对较简单67 * 思想:68 * (1)若栈非空或者结点非空,则进入循环69 * (2)若结点非空,读取该节点,并将结点压入栈中,结点向左孩子移动,移到最左孩子70 * (3)若栈非空,取出栈顶元素,此时父节点已读,所以移向右孩子71 * 核心为:边读取左结点变将其压入栈中,左孩子对下一级来说上也代表父亲结点,所以之后可以直接读取右孩子。72 */
73 public voidpreOrder1()74 {75 Stack stack = new Stack<>();76 TreeNode node =root;77 while(!stack.isEmpty()||node!=null)78 {79 while(node!=null)80 {81 System.out.print(node.data+" "); //访问该节点
82 stack.push(node);83 node =node.lchild;84 }85 if(!stack.isEmpty())86 {87 node =stack.pop();88 node =node.rchild;89 }90 }91 }92 /*
93 * 方法二:先序遍历,使用栈操作,相对较麻烦94 * 思想:95 * (1)首先将根节点入栈96 * (2)判断非空,将结点从栈中取出并访问97 * (3)依次访问栈中的左孩子,并将右孩子放入栈中,结点不断往左孩子移动98 * (4)重复步骤(2)(3),直到栈为空99 */
100 public void preOrder2() throwsException101 {102 TreeNode pNode =root;103 if(pNode!=null) //首先判断根结点是否为空
104 {105 Stack astack = new Stack<>(); //构造栈操作
106 astack.push(pNode); //将根节点压入栈中
107 while(!astack.isEmpty()) //循环操作直到栈中没有结点存在,即最右结点访问完毕
108 {109 pNode = astack.pop(); //首先将结点从栈中取出
110 System.out.print(pNode.data+" "); //访问该节点
111 while(pNode!=null) //若该结点不为空
112 {113 if(pNode.lchild!=null) //访问左子树
114 System.out.print(pNode.lchild.data+" ");115 if(pNode.rchild!=null) //将右子树压入栈中
116 astack.push(pNode.rchild);117 pNode = pNode.lchild; //进入到下一个左子树中
118 }119 }120
121 }122 }123 //中序遍历,递归操作
124 public voidinOrder(TreeNode root)125 {126 if(root==null)127 return;128 inOrder(root.lchild);129 System.out.print(root.data+" ");130 inOrder(root.rchild);131 }132 /*
133 * 中序遍历,使用栈操作134 * 思想:135 * (1)若栈非空或者结点非空,则进入循环136 * (2)若结点非空,则将结点压入栈中,结点向左孩子移动,一直到最左边137 * (3)若栈非空,则取出栈顶元素,并读取访问数据,而后结点向右孩子移动138 */
139 public void inOrder1() throwsException140 {141 TreeNode node =root;142 Stack stack = new Stack<>();143 while(node!=null||!stack.isEmpty())144 {145 while(node!=null)146 {147 stack.push(node);148 node =node.lchild;149 }150 if(stack!=null)151 {152 node =stack.pop();153 System.out.print(node.data+" ");154 node =node.rchild;155 }156 }157 }158 //后序遍历,递归操作
159 public voidpostOrder(TreeNode root)160 {161 if(root==null)162 return;163 postOrder(root.lchild);164 postOrder(root.rchild);165 System.out.print(root.data+" ");166 }167 /*
168 * 后序遍历,栈操作169 * 前提:设置标志结点pre,指示是否访问过某结点170 * 思想:171 * (1)若栈非空或者结点非空,则进入循环172 * (2)若结点非空,则将结点压入栈中,结点向左孩子移动,一直到最左边173 * (3)若栈非空,首先取出栈顶元素的右孩子赋给tmp174 * 1、若栈顶元素的右孩子为空或者等于pre(即已访问过),则弹出元素并访问,将该结点赋值给pre,并将当前结点赋值为null175 * 2、否则的话将右孩子赋值给当前结点176 */
177 public voidpostOrder1()178 {179 Stack stack = new Stack<>();180 TreeNode node = root,pre =root;181 while(!stack.isEmpty()||node!=null)182 {183 while(node!=null)184 {185 stack.push(node);186 node =node.lchild;187 }188 if(!stack.isEmpty())189 {190 TreeNode tmp =stack.peek().rchild;191 if(tmp==null||tmp==pre)192 {193 node =stack.pop();194 System.out.print(node.data+" ");195 pre =node;196 node = null;197 }else{198 node =tmp;199 }200
201 }202 }203
204 }205 /*层次遍历,即广度优先遍历,从上到下遍历二叉树206 * 思想:207 * (1)读取根节点,并将其压入队列中208 * (2)以队列的长度作为循环的判断条件,取出队收元素并访问,访问后将其弹出209 * (3)判断是否有左右孩子,若有则加入队列中。210 **/
211 public voidbfs()212 {213 Queue queue = newLinkedList();214 if(root==null)215 return;216 queue.offer(root);217 while(queue.size()>0) {218 TreeNode node =queue.peek();219 queue.poll();220 System.out.print(node.data+" ");221 if(node.lchild!=null)222 {223 queue.offer(node.lchild);224 }225 if(node.rchild!=null)226 {227 queue.offer(node.rchild);228 }229 }230
231 }232 /*
233 * 深度优先遍历,从左到右遍历二叉树234 **/
235 public void dfs(TreeNode node,List> nList,Listlist)236 {237 if(node==null)238 return;239 if(node.lchild==null&node.rchild==null)240 {241 list.add((Integer) node.data);242 nList.add(new ArrayList<>(list));243 list.remove(list.size()-1);244 }245 list.add((Integer) node.data);246 dfs(node.lchild, nList, list);247 dfs(node.rchild, nList, list);248 list.remove(list.size()-1);249 }250 //查找算法
251 public static TreeNode Searchparameter(TreeNode root,intx)252 {253 TreeNode node =root;254 if(root==null)255 return null;256 else{257 if(node.data.equals(x))258 returnnode;259 else{260 TreeNode aNode =Searchparameter(node.lchild, x);261 if(aNode==null)262 returnSearchparameter(node.rchild, x);263 else
264 returnaNode;265 }266 }267 }268 //求二叉树的深度
269 public intDepth(TreeNode node)270 {271 if(node==null)272 return 0;273 else{274 int ldepth =Depth(node.lchild);275 int rdepth =Depth(node.rchild);276 if(ldepth
279 return ldepth+1;280 }281 }282 public static void main(String[] args) throwsException {283 int datas[] = {1,2,3,4,5,6,7,8,9,10};284 List nodelist = new LinkedList<>();285 Main aMain = newMain();286 aMain.CreatBinTree(datas,nodelist);287 root = nodelist.get(0);288
289 System.out.println("First order traversal(recursive):");290 aMain.PreOrder(root);291 System.out.println();292 System.out.println("First order traversal(stack--1):");293 aMain.preOrder1();294 System.out.println();295 System.out.println("First order traversal(stack--2):");296 aMain.preOrder2();297 System.out.println();298 System.out.println("Inorder traversal(recursive):");299 aMain.inOrder(root);300 System.out.println();301 System.out.println("Inorder traversal(stack--1):");302 aMain.inOrder1();303 System.out.println();304 System.out.println("Postorder traversal(recursive):");305 aMain.postOrder(root);306 System.out.println();307 System.out.println("Postorder traversal(stack--1):");308 aMain.postOrder1();309 System.out.println();310 System.out.println("Level traversal(queue--1):");311 aMain.bfs();312
313 List> rst = new ArrayList<>();314 List list = new ArrayList<>();315 System.out.println();316 System.out.println("Depth first traversal(queue--1):");317 aMain.dfs(root,rst,list);318 System.out.println(rst);319 int x = 6;320 TreeNode aNode =Searchparameter(root,x);321 System.out.println(aNode.data);322
323 int depth =aMain.Depth(root);324 System.out.println("the depth of the tree is :"+depth);325 }326
327
328 }
结果展示: