二叉树常见方法整理（1 遍历）

最新推荐文章于 2022-03-29 16:19:59 发布
最新推荐文章于 2022-03-29 16:19:59 发布
阅读量225 收藏
点赞数
分类专栏： 算法 文章标签： 二叉树 遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bohu83/article/details/79960370
版权

序

最近在看jdk的时候，发现一些底层还是使用了二叉树的相关知识，由此可以扩展开红黑树，或者MySQL的索引B+树。

补充一些知识点。

二叉树：

1、深度优先：递归，非递归实现方式
　　1)先序遍历：先访问根节点，再依次访问左子树和右子树
　　2)中序遍历：先访问左子树，再访问根节点吗，最后访问右子树
　　3)后序遍历：先访问左子树，再访问右子树，最后访问根节点

        其中后序遍历是最复杂的。：举例两种不同的实现方式：

       a)   对于任意节点current，若该节点不为空则访问该节点后再将节点压栈，并将左子树节点置为current，重复此操作，直到current为空。 若左子树为空，取栈顶节点的右子树，如果右子树为空或右子树刚访问过，则访问该节点，并将preNode置为该节点 

      b)要保证根结点在左孩子和右孩子访问之后才干访问，因此对于任一结点P。先将其入栈。假设P不存在左孩子和右孩子。则能够直接访问它；或者P存在左孩子或者右孩子。可是其左孩子和右孩子都已被访问过了。

   对我来说，其中b更容易理解一些，还有双栈的实现方式更难理解就没贴。

2、广度优先

    按照树的深度，一层一层的访问树的节点。


节点类

package com.daojia.collect;
/**
 * 
 * @author daojia
 *
 */
public class Node {

	  int  value;  
	  Node leftChild;  
	  Node rightChild; 
	  
	  Node(int value) {  
	        this.value = value;  
	  }  
	      
	  public void display() {  
	     System.out.print(this.value + ",");  
	  }  
	  
	   @Override  
	 public String toString() {	        
	    return String.valueOf(value);  
	 }  
	
}
package com.daojia.collect;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;

public class Btree {

	 private Node root = null;  
     
	 Btree(int value) {  
	        root = new Node(value);  
	        root.leftChild  = null;  
	        root.rightChild = null;  
	    }  
	//查找  
	    public Node findKey(int value) {
	    	Node current  = root ;
	    	while(true){
	    		if(current.value== value)
	    		{
	    			return current;
	    		}
	    		else if(current.value>value){
	    			
	    			 current = current.leftChild;
	    		}else if(current.value < value){
	    			current = current.rightChild;
	    		}
	    		if(current == null){
	    			return null;
	    		}
	    	}	    	
	
	    }   
	  //插入  
	        public Node insert(int value) {
	        	String error = null;  
	        	  
	        	Node node = new Node(value);  
	        	if (root == null) {  
	        	    root = node;  
	        	    root.leftChild  = null;  
	        	    root.rightChild = null;  
	        	} else {  
	        	    Node current = root;  
	        	    Node parent = null;  
	        	    while (true) {  
	        	        if (value < current.value) {  
	        	            parent = current;  
	        	            current = current.leftChild;  
	        	            if (current == null) {  
	        	                parent.leftChild = node;  
	        	                break;  
	        	            }  
	        	        } else if (value > current.value) {  
	        	            parent = current;  
	        	            current = current.rightChild;  
	        	            if (current == null) {  
	        	                parent.rightChild = node;  
	        	                break;  
	        	            }  
	        	        } else {  
	        	            System.out.println("exists");
	        	            break;
	        	        }     
	        	    } // end of while  
	        	}
	        	return node;
	        }  
	        //中序遍历递归操作  
	        public void inOrderTraverse() {
	            System.out.print("中序递归：");
	        	 inOrderTraverse(root);
	        	 System.out.println();
	        }
	        /**
	         * （递归）先遍历左子树，在跟节点，再遍历右子树
	         * @param node
	         */
	        private void inOrderTraverse(Node node) {  
	            if (node == null)   
	                return ;  
	        
	            inOrderTraverse(node.leftChild);  
	            node.display();  
	            inOrderTraverse(node.rightChild);  
	        }
	        /**
	         * 非递归遍历
	         * 1）对于任意节点current，若该节点不为空则将该节点压栈，并将左子树节点置为current，重复此操作，直到current为空。 
	         * 2）若左子树为空，栈顶节点出栈，访问节点后将该节点的右子树置为current 
	         * 3) 重复1、2步操作，直到current为空且栈内节点为空。 
	         */
	        public  ArrayList<Integer> inOrderByStack() {
	        	System.out.print("中序非递归：");
	        	ArrayList<Integer> list = new ArrayList<Integer>();
	        	Stack<Node> stack = new Stack<Node>();
	        	Node current = root;
	        	
	        	while(current != null ||!stack.isEmpty())
	        	{
	        		while(current != null){
	        		stack.push(current);
	        		current = current.leftChild;
	        		}
	        		
	        		if(!stack.isEmpty())
	        		{
	        			current =stack.pop();
	        			list.add(current.value);
	        			current = current.rightChild;
	        		}
	        	}
	        	return list;
	        }
	        //前序遍历  
	        public void preOrderTraverse() {
	        	System.out.print("前序遍历:");  
	            preOrderTraverse(root);
	            System.out.println("");    
	        }  
	        private void preOrderTraverse(Node node) {
	        	  if (node == null)   
		                return ;  
	        	  node.display();  
	        	  preOrderTraverse(node.leftChild);           
	        	  preOrderTraverse(node.rightChild);  
	        }
	        //前序遍历非递归操作  
	        public ArrayList<Integer> preOrderByStack() {
	        	System.out.print("前序遍历 非递归:");  
	        	ArrayList<Integer> list = new ArrayList<Integer>();
	        	Stack<Node> stack = new Stack<Node>();
	        	Node current = root;
	        	while(current != null || !stack.isEmpty())
	        	{
	        		while(current != null){
	        			stack.push(current);
	        			list.add(current.value);
	        			current = current.leftChild;
	        			
	        		}
	        		if( !stack.isEmpty()){
	        			current = stack.pop();
	        			current = current.rightChild;
	        		}
	        		
	        	}
	        	
	        	return list;
	        	
	        }  
	      //后序遍历  
	        public void postOrderTraverse() {
	        	System.out.print("后序遍历：");
	        	postOrderTraverse(root);
	        	System.out.println("");
	        }
	        private void postOrderTraverse(Node node){
	        	if(node == null){
	        		return;
	        	}
	        	postOrderTraverse(node.leftChild);
	        	postOrderTraverse(node.rightChild);
	        	node.display();
	        }
	        /**
	         * 1）对于任意节点current，若该节点不为空则访问该节点后再将节点压栈，并将左子树节点置为current，重复此操作，直到current为空。 
             * 2）若左子树为空，取栈顶节点的右子树，如果右子树为空或右子树刚访问过，则访问该节点，并将preNode置为该节点 
	         */
	        public ArrayList<Integer> postOrderByStack() {
	        	System.out.print("后序遍历 非递归:");  
	        	ArrayList<Integer> list = new ArrayList<Integer>();
	        	Stack<Node> stack = new Stack<Node>();
	        	Node current = root;
	        	Node preNode = null;  
	        	while(current != null || !stack.isEmpty())
	        	{
	        		while(current != null){
	        			stack.push(current);	        		
	        			current = current.leftChild;
	        			
	        		}
	        		if( !stack.isEmpty()){
	        			 current = stack.peek().rightChild;  
	                     if (current == null || current == preNode) {  
	                         current = stack.pop();  
	                         list.add(current.value);  
	                         preNode = current;  
	                         current = null;  
	                     }  	        				        			
	        		}	        		
	        	}
	        	
	        	return list;
	        } 
	        //后序遍历非递归操作 
	        public ArrayList<Integer> postOrderByStack2() {
	        	System.out.print("后序遍历 非递归:");  
	        	ArrayList<Integer> list = new ArrayList<Integer>();
	        	Stack<Node> stack = new Stack<Node>();
	        	Node current = null;
	        	Node preNode = null; 
	        	stack.push(root);
	        	while(!stack.isEmpty())
	        	{	        		
	        			 current = stack.peek();
	        			 //当前节点没有孩子节点或者左右孩子节点都被访问过
	                     if( (current.leftChild == null&¤t.rightChild== null) ||
	                    		 (current!= null&&(current.leftChild == preNode|| current.rightChild== preNode)) ) {  
	                         stack.pop();  
	                         list.add(current.value);  
	                         preNode = current;  
	                      
	                     }else{                    	 
	                  
	                    	 if(current.rightChild != null ){
	                    		 stack.push(current.rightChild);
	                    	 }
	                      	 if(current.leftChild != null ){
	                    		 stack.push(current.leftChild);
	                    	 }
	                     }
	        		       		
	        	}
	        	
	        	return list;
	        }
	        /**
	         * 广度优先遍历
	         * @return
	         */
	        public ArrayList<Integer> levelTraverse(){
	        	LinkedList<Node>  queue = new LinkedList<Node>();
	        	ArrayList<Integer> list = new ArrayList<Integer>();
	        	System.out.print("广度优先遍历 :");
	        	queue.add(root);
	        	while(!queue.isEmpty()){
	        		Node current = queue.poll();
	        		  list.add(current.value);
	        		  if(current.leftChild != null){
	        			  queue.add(current.leftChild);
	        		  }
	        		  if(current.rightChild != null){
	        			  queue.add(current.rightChild);
	        		  }
	        	}
				return list;
	        	
	        }
	        /**
	         * 得到最小值
	         * @return
	         */
	        public int getMinValue() {
	        	System.out.print("最小值：");
	        	Node current = root;
	        	while(true){
	        		
	        		if(current.leftChild == null)
	        		{
	        			return current.value;
	        		}
	        		current = current.leftChild;
	        	}
	        	
	        } 
	        //得到最大值
	        public int getMaxValue(){
	        	System.out.print("最大值：");
	        	Node current = root;
	        	while(true){
	        		
	        		if(current.rightChild == null)
	        		{
	        			return current.value;
	        		}
	        		current = current.rightChild;
	        	}
	        }
	    
	
	        public static void main(String[] args){
	        	
	        	Btree tree = new Btree(10);
	        	tree.insert(7);
	        	tree.insert(8);
	        	tree.insert(9);
	        	tree.insert(12);
	        	tree.insert(11);
	        	tree.insert(13);
	        	System.out.println(tree.insert(1));
	        	tree.inOrderTraverse();
	        	System.out.println(tree.inOrderByStack().toString());
	        	tree.preOrderTraverse();	        
	        	System.out.println(tree.preOrderByStack().toString());
	        	tree.postOrderTraverse();
	        	System.out.println(tree.postOrderByStack().toString());
	        	System.out.println(tree.postOrderByStack2().toString());
	        	System.out.println(tree.levelTraverse().toString());
	        	System.out.println(tree.getMinValue());
	        	System.out.println(tree.getMaxValue());
	        	
	        }
}

补充下栈的含义：pop 与peek,都返回栈顶的值。

不同点：peek 不改变栈的值(不删除栈顶的值)，pop会把栈顶的值删除。

返回getMin栈的最小值。

运行结果：

1
中序递归：1,7,8,9,10,11,12,13,
中序非递归：[1, 7, 8, 9, 10, 11, 12, 13]
前序遍历:10,7,1,8,9,12,11,13,
前序遍历 非递归:[10, 7, 1, 8, 9, 12, 11, 13]
后序遍历：1,9,8,7,11,13,12,10,
后序遍历 非递归:[1, 9, 8, 7, 11, 13, 12, 10]
后序遍历 非递归:[1, 9, 8, 7, 11, 13, 12, 10]
广度优先遍历 :[10, 7, 12, 1, 8, 11, 13, 9]
最小值：1
最大值：13

待续：。。。 

参考：

https://blog.csdn.net/fengrunche/article/details/52305748

bohu83
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树递归与非递归遍历
11-03
二叉树递归与非递归遍历
数据结构笔记（二叉树）
weixin_44779139的博客
05-26 699
目录 前言 一、二叉树的定义 二、满二叉树和完全二叉树 1）满二叉树 2）完全二叉树 三、二叉树的性质 四、二叉树的存储结构 1）二叉树的顺序存储结构 2）二叉树的链式存储结构 1.二叉链结点类 2.二叉树类的设计 3.二叉树基本运算算法的实现 五、二叉树的遍历 1.二叉树遍历实现 1）先序遍历 2）中序遍历 3）后序遍历 2.递归遍历的应用 1）求给定二叉树中结点的个数 2）从左到右输出所有叶子结点 3）将顺序存储结构转换为二叉链 六、线索二叉树 1.线.
Java实现二叉树的先序、中序、后序遍历算法
weixin_43670251的博客
03-13 1561
Java实现二叉树的先序、中序、后序遍历算法 一、构建二叉树的存储结构 一棵二叉树的节点结构主要包括三部分：节点的值域，指向左孩子的指针，指向右孩子的指针。由于Java语言没有指针的定义，这里采用属性的方式实现(重写equals方法是为了后续遍历非递归算法的需要，后面会说明)。代码如下： import java.util.Objects; /** * @author:Chris * @date:2021/2/25 * @description 二叉树结点结构 */ public class BiT
java先序遍历建树_Java实现二叉树的(根据一维数组)构建和先序中序后序遍历
weixin_35045970的博客
02-27 244
Java实现二叉树1. 定义结点类public class TreeNode {int val = 0;TreeNode left = null;TreeNode right = null;public TreeNode(int val) {this.val = val;}}2. 构建二叉树public static TreeNode createBT(int[] arr, int i) // 初...
二叉树的java实现与几种遍历
Thomas-yang的专栏
05-07 1446
package com.tree; public class BinaryTree { private int data;//数据节点 private BinaryTree left; private BinaryTree right; public BinaryTree(int data){ this.data = data; this.left = null; thi
二叉搜索树的实现（包含插入、查找、遍历、删除等）【Java版】
yulutian的博客
03-08 476
package com.BinarySearchTree; import java.util.LinkedList; /** *实现二分搜索树 *O(logn) *适用于查找表（字典） //定义树的结点 private class Node { private Key key; //键，相当于字典中的单词 private Value v...
二叉树遍历问题-二叉树遍历问题
11-12
二叉树遍历问题-二叉树遍历问题
二叉树遍历问题二叉树遍历问题
最新发布
10-20
二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题二叉树遍历问题...
Python实现二叉树结构与进行二叉树遍历的方法详解
09-21
二叉树是最基本的数据结构,这里我们在Python中使用类的形式来实现二叉树并且用内置的方法来遍历二叉树,下面就让我们一起来看一下Python实现二叉树结构与进行二叉树遍历的方法详解
Python二叉树的定义及常用遍历算法分析
09-21
主要介绍了Python二叉树的定义及常用遍历算法,结合实例形式分析了基于Python的二叉树定义与先序、中序、后序、层序等遍历方法,需要的朋友可以参考下
一文弄懂二叉树的三种遍历方式
高性能架构探索
08-31 2万+
关注公众号:高性能架构探索。后台回复【资料】，可以免费领取 俗话说：学如逆水行舟,不进则退;心似平原走马,易放难收。这句话对程序员而言，体会更深。这行已经越来越卷了，时刻准备着，????。 二叉树，在面试中，已是必备的开胃菜。而在二叉树相关的面试题目中，遍历更是常考题目。本文将从二叉树的遍历角度入手，从递归和非递归角度来分析和讲解二叉树的遍历。 遍历 二叉树的遍历是指从根节点出发，按照某种次序依次访问二叉树中的所有节点，使每个节点被且仅被访问一次。 二叉树的遍历，有先序遍历、中序遍历以
二叉树的四种遍历方式
weixin_42127177的博客
02-16 9236
中序遍历 二叉树的中序遍历就是首先遍历左子树，然后访问当前节点，最后遍历右子树。对于下面的二叉树，中序遍历结果如下： 直观来看，二叉树的中序遍历就是将节点投影到一条水平的坐标上。如图： 二叉树结构 struct treenode { int val; treenode *left; treenode *right; treenode() : val(0), left(nullptr), right(nullptr) {} treenode(in
二叉树的五种遍历方式
weixin_47382783的博客
03-29 1万+
目录 1、前序遍历 （1）递归实现前序遍历 （2）非递归实现前序遍历 2、中序遍历 （1）递归实现中序遍历 （2）非递归实现中序遍历 3、后序遍历 （1）递归实现后序遍历 （2）非递归实现后序遍历 4、层序遍历 二叉树是一种重要的数据结构，其遍历方式分为：深度遍历和广度遍历，深度遍历有前序、中序以及后序三种遍历方法，广度遍历即就是层次遍历。如下图： class TreeNode{ int val; TreeNode left; TreeNode ..
二叉树遍历的几种常见方法
热门推荐
xie_bro的博客
10-27 2万+
二叉树的遍历方法 一.二叉树分类： 完全二叉树 满二叉树 扩充二叉树 平衡二叉树 二.二叉树的四种遍历方式： 前序遍历（先根，再左，最后右） 中序遍历（先左，再根，最后右） 后序遍历（先左，再右，最后根） 层次遍历（说不清） 1.递归遍历 （1）前序遍历 遍历方法：先根节点，再左节点，最后右节点。 实现代码： /*声明结点TreeNode类*/ public static void preOrderTraveral(TreeNode node){ if(node == null){
重温数据结构：二叉树的常见方法及三种遍历方式 Java 实现
张拭心的博客 shixinzhang
11-17 2万+
读完本文你将了解到： 什么是二叉树 Binary Tree 两种特殊的二叉树 满二叉树 完全二叉树 满二叉树 和 完全二叉树 的对比图 二叉树的实现 用 递归节点实现法左右链表示法 表示一个二叉树节点 用 数组下标表示法 表示一个节点 二叉树的主要方法 二叉树的创建 二叉树的添加元素 二叉树的删除元素 二叉树的清空 获得二叉树的高度 获得二叉树的节点数 获得某个节点的父亲节点 二叉树的遍历 先序遍历
二叉树的构造及常用方法
hwx1829200的博客
05-07 3529
二叉树   定义：二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。         特点：二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2^(i-1)个结点；深度为k的二叉树至多有2^k-
二叉树遍历几种常见方式
liu_wenbin的博客
08-16 468
前序遍历递归版本public List<Integer> preorderTraversal(TreeNode root) { List<Integer> res = new LinkedList<Integer>(); preHelper(root,res); return res; } public void preHelper(TreeN
讲透学烂二叉树(二)：图中树的定义&各类型树的特征分析
周陆军的博客，分享it技术。
06-06 810
日常中我们见到的二叉树应用有，Java集合中的TreeSet和TreeMap，C++ STL中的set、map，以及Linux虚拟内存的管理，以及B-Tree，B+-Tree在文件系统，都是通过红黑树去实现的。虽然之前写过《再谈堆排序：堆排序算法流程步骤透解—最大堆构建原理》但是二叉树的基本性质，对我来说，从入门到放弃是搞了好几回。 树的基本概念 树（Tree）：树是一种数据结构，可以表示层次关系，它是由n（n>=1）个有限节点组成一个具有层次关系的集合。形状像一棵倒挂的树。 树：不包含回路的连
二叉树的三种遍历方式java实现
Crystalqy的博客
04-19 724
二叉树的特点：性质1：在二叉树的第i层上至多有2^(i-1)个节点(i &gt;= 1)性质2：深度为k的二叉树至多有2^k-1个节点(k &gt;=1)性质3：对于任意一棵二叉树T而言，其叶子节点数目为N0,度为2的节点数目为N2，则有N0 = N2 + 1。性质4：具有n个节点的完全二叉树的深度 。二叉树遍历理论知识二叉树遍历java实现package com.person.spring.si...
DS二叉树—二叉树构建与遍历
10-20
DS二叉树的遍历方式与普通二叉树的遍历方式类似，包括先序遍历、中序遍历和后序遍历。其中，先序遍历是指先访问根节点，然后依次访问左子树和右子树；中序遍历是指先访问左子树，然后访问根节点，最后访问右子树；...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值