二叉树的构建和遍历

最新推荐文章于 2025-03-11 13:13:05 发布
最新推荐文章于 2025-03-11 13:13:05 发布
阅读量1.2k 收藏 1
点赞数 2
分类专栏： 算法与数据结构 文章标签： 二叉树构建 java 递归遍历 栈遍历 深度优先遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lilong117194/article/details/83828148
版权

（1）下面二叉树的构建是通过一个数组来构造二叉树
[ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ] { [1, 2, 3, 4, 5, 6, 7, 8, 9 ]} [1,2,3,4,5,6,7,8,9]

  1. 将数组元素转换成n个Node节点（n为数组大小，这里是9）。
  2. 用LinkedList数据结构存储成n个Node节点。
  3. 先处理前 ( n / 2 − 1 ) = 3 (n/2-1)=3 (n/2−1)=3个父节点，因为数组是从下标0开始的，所以这里的3个父节点，即是下标为0、1、2的节点，然后处理最后1个父节点即下标为3的节点，因为最后一个父节点可能没有右孩子，当n为奇数时才有右孩子，为偶数时只有左孩子。
  4. 父节点索引与左右孩子索引的关系：左孩子索引= ( n / 2 + 1 ) (n/2+1) (n/2+1)；右孩子索引= ( n / 2 + 2 ) (n/2+2) (n/2+2)，这里如果按 n / 2 n/2 n/2和 n / 2 + 1 n/2+1 n/2+1来表示的话，由于下标是从0开始的，这样下标为0的父节点的子节点就是0和1，很明显是有问题的，所以才要分别加1。

（2）遍历
遍历是对树的一种最基本的运算，就是按一定的规则和顺序走遍二叉树的所有结点，使每一个结点都被访问一次，而且只被访问一次。由于二叉树是非线性结构，因此，树的遍历实质上是将二叉树的各个结点转换成为一个线性序列来表示。
设L、D、R分别表示遍历左子树、访问根结点和遍历右子树， 则对一棵二叉树的遍历有三种情况：DLR（称为先根次序遍历），LDR（称为中根次序遍历），LRD （称为后根次序遍历）。即遍历的次序是根据父节点的位置而定的。

例子1:

import java.util.LinkedList;  
import java.util.List; 

/**
 * 功能：把一个数组的值存入二叉树中，然后进行3种方式的遍历 
 */

public class TestBinaryTree {

	public static void main(String[] args) {  
		TestBinaryTree binTree = new TestBinaryTree();  
        binTree.createBinTree();           
        Node root = nodeList.get(0);  // nodeList中第0个索引处的值即为根节点
        
        System.out.println("先序遍历：");  
        preOrderTraverse(root);  
        System.out.println();  
  
        System.out.println("中序遍历：");  
        inOrderTraverse(root);  
        System.out.println();  
  
        System.out.println("后序遍历：");  
        postOrderTraverse(root);  
    }  
	
	
	private int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };  
    private static List<Node> nodeList = null; 
    
    
    // 内部静态类：节点类
    private static class Node {  
        Node leftChild;  
        Node rightChild;  
        int data;  
  
        Node(int newData) {  
            leftChild = null;  
            rightChild = null;  
            data = newData;  
        }  
    }  
        
    public void createBinTree() { 
    	
         nodeList = new LinkedList<Node> ();  
         // 将一个数组的值依次转换为Node节点  
         for (int nodeIndex = 0; nodeIndex < array.length; nodeIndex++) {  
             nodeList.add(new Node(array[nodeIndex]));  
         }  
  
         // 对前lastParentIndex-1个父节点按照父节点与孩子节点的数字关系建立二叉树  
         for (int parentIndex = 0; parentIndex < array.length / 2 - 1; parentIndex++) {               
             nodeList.get(parentIndex).leftChild = nodeList.get(parentIndex * 2 + 1);   // 左孩子  
             nodeList.get(parentIndex).rightChild = nodeList.get(parentIndex * 2 + 2);  // 右孩子  
         }  
         // 最后一个父节点:因为最后一个父节点可能没有右孩子，所以单独拿出来处理  
         int lastParentIndex = array.length / 2 - 1;          
         nodeList.get(lastParentIndex).leftChild = nodeList.get(lastParentIndex * 2 + 1);  // 左孩子  
         if (array.length % 2 == 1) {                         
             nodeList.get(lastParentIndex).rightChild = nodeList.get(lastParentIndex * 2 + 2);  // 右孩子,如果数组的长度为奇数才建立右孩子
         }  
     } 
 
    
    // 先序遍历（传入的是根节点）
    public static void preOrderTraverse(Node node) {  
        if (node == null)  
            return;  
        System.out.print(node.data + " ");  
        preOrderTraverse(node.leftChild);  
        preOrderTraverse(node.rightChild);  
    }  
  
    // 中序遍历 （（传入的是根节点））
    public static void inOrderTraverse(Node node) {  
        if (node == null)  
            return;  
        inOrderTraverse(node.leftChild);  
        System.out.print(node.data + " ");  
        inOrderTraverse(node.rightChild);  
    }  
  
    // 后序遍历（（传入的是根节点））
    public static void postOrderTraverse(Node node) {  
        if (node == null)  
            return;  
        postOrderTraverse(node.leftChild);  
        postOrderTraverse(node.rightChild);  
        System.out.print(node.data + " ");  
    } 

 }

运行：

先序遍历：
1 2 4 8 9 5 3 6 7 
中序遍历：
8 4 9 2 5 1 6 3 7 
后序遍历：
8 9 4 5 2 6 7 3 1

例子2:

下面这个例子对二叉树的学习更全面

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;
 
public class TestBinaryTree {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TestBinaryTree tree = new TestBinaryTree();
		int[] datas = new int[]{1,2,3,4,5,6,7,8,9};
		List<Node> nodelist = new LinkedList<>();
		tree.creatBinaryTree(datas, nodelist);
		Node root = nodelist.get(0);    // nodelist中的0索引存储的是根节点
		//System.out.println("递归先序遍历：");
		//tree.preOrderTraversal(root);
		//System.out.println();
		System.out.println("非递归先序遍历：");		
		tree.preOrderTraversalbyLoop(root);
		System.out.println();
		System.out.println("递归中序遍历：");
		tree.inOrderTraversal(root);
		System.out.println();
		System.out.println("非递归中序遍历：");
		tree.inOrderTraversalbyLoop(root);
		System.out.println();
		System.out.println("递归后序遍历：");
		tree.postOrderTraversal(root);
		System.out.println();
		System.out.println("非递归后序遍历：");
		tree.postOrderTraversalbyLoop(root);
		System.out.println();
		System.out.println("广度优先遍历：");
		tree.bfs(root);
		System.out.println();
		System.out.println("深度优先遍历：");
		List<List<Integer>> rst = new ArrayList<>();
		List<Integer> list = new ArrayList<>();
		tree.dfs(root,rst,list);
		System.out.println(rst);
		
	}
	
	/**
	 * 
	 * @param datas 实现二叉树各节点值的数组
	 * @param nodelist 二叉树list
	 */
	private void creatBinaryTree(int[] datas,List<Node> nodelist){
		//将数组变成node节点
		for(int nodeindex=0;nodeindex<datas.length;nodeindex++){
			Node node = new Node(datas[nodeindex]);
			nodelist.add(node);
		}
		//给所有父节点设定子节点
		for(int index=0;index<nodelist.size()/2-1;index++){
			//编号为n的节点他的左子节点编号为2*n 右子节点编号为2*n+1 但是因为list从0开始编号，所以还要+1
			//这里父节点有1（2,3）,2（4,5）,3（6,7）,4（8,9） 但是最后一个父节点有可能没有右子节点 需要单独处理
			nodelist.get(index).setLeft(nodelist.get(index*2+1)); 
			nodelist.get(index).setRight(nodelist.get(index*2+2));
		}
		//单独处理最后一个父节点  因为它有可能没有右子节点
		int index = nodelist.size()/2-1;
		nodelist.get(index).setLeft(nodelist.get(index*2+1)); //先设置左子节点
		if(nodelist.size() % 2 == 1){ //如果有奇数个节点，最后一个父节点才有右子节点
			nodelist.get(index).setRight(nodelist.get(index*2+2));
		}
	}
	/**
	 * 遍历当前节点的值
	 * @param nodelist
	 * @param node
	 */
	public void checkCurrentNode(Node node){
		System.out.print(node.getVar()+" ");
	}
	
	/**
	 * 非递归前序遍历
	 * @param node
	 */
	public void preOrderTraversalbyLoop(Node node){
		Stack<Node> stack = new Stack();  // 栈：FILO
		Node p = node;
		while(p!=null || !stack.isEmpty()){
			while(p!=null){       //当p不为空时，就读取p的值，并不断更新p为其左子节点，即不断读取左子节点
				checkCurrentNode(p); //打印输出p节点的值
				stack.push(p);    //将p入栈
				p = p.getLeft();  // 更新p的左子节点
			}
			if(!stack.isEmpty()){
				p = stack.pop();
				p = p.getRight();
			}
		}
	}
	/**
	 * 非递归中序遍历
	 * @param node
	 */
	public void inOrderTraversalbyLoop(Node node){
		Stack<Node> stack = new Stack();
		Node p = node;
		while(p!=null || !stack.isEmpty()){
			while(p!=null){
				stack.push(p);
				p = p.getLeft();
			}
			if(!stack.isEmpty()){	
				p = stack.pop();
				checkCurrentNode(p);
				p = p.getRight();
			}
		}
	}
	/**
	 * 非递归后序遍历
	 * @param node
	 */
	public void postOrderTraversalbyLoop(Node node){
		Stack<Node> stack = new Stack<>();
		Node p = node,prev = node;
		while(p!=null || !stack.isEmpty()){
			while(p!=null){
				stack.push(p);
				p = p.getLeft();
			}
			if(!stack.isEmpty()){
				Node temp = stack.peek().getRight();  // peek()查看栈顶的对象而不移除它。
				if(temp == null||temp == prev){
					p = stack.pop();
					checkCurrentNode(p);
					prev = p;
					p = null;
				}else{
					p = temp;
				}	
			}
		}
	}
	
	
	/**
	 * 先序遍历二叉树
	 * @param root 二叉树根节点
	 */
	public void preOrderTraversal(Node node){
		if (node == null)  //很重要，必须加上 当遇到叶子节点用来停止向下遍历
            return;  
		checkCurrentNode(node);
		preOrderTraversal(node.getLeft());
		preOrderTraversal(node.getRight());
	}
	/**
	 * 中序遍历二叉树
	 * @param root 根节点
	 */
	public void inOrderTraversal(Node node){
		if (node == null)  //很重要，必须加上
            return;  
		inOrderTraversal(node.getLeft());
		checkCurrentNode(node);
		inOrderTraversal(node.getRight());
	}
	/**
	 * 后序遍历二叉树
	 * @param root 根节点
	 */
	public void postOrderTraversal(Node node){
		if (node == null)  //很重要，必须加上
            return;  
		postOrderTraversal(node.getLeft());
		postOrderTraversal(node.getRight());
		checkCurrentNode(node);
	}
	
	
	/**
	 * 广度优先遍历（从上到下遍历二叉树）
	 * @param root
	 */
	public void bfs(Node root){
		  if(root == null) return;
		  LinkedList<Node> queue = new LinkedList<Node>();
		  queue.offer(root); //首先将根节点存入队列
		  //当队列里有值时，每次取出队首的node打印，打印之后判断node是否有子节点，若有，则将子节点加入队列
		  while(queue.size() > 0){ 
			Node node = queue.peek();
		    queue.poll(); //取出队首元素并打印
		    System.out.print(node.var+" ");
		    if(node.left != null){ //如果有左子节点，则将其存入队列
		      queue.offer(node.left);
		    }
		    if(node.right != null){ //如果有右子节点，则将其存入队列
		      queue.offer(node.right);
		    }
		  }
	}
	/**
	 * 深度优先遍历
	 * @param node
	 * @param rst
	 * @param list
	 */
	public void dfs(Node node,List<List<Integer>> rst,List<Integer> list){
		if(node == null) return;
		if(node.left == null && node.right == null){
			list.add(node.var);
			/* 这里将list存入rst中时，不能直接将list存入，而是通过新建一个list来实现，
			 * 因为如果直接用list的话，后面remove的时候也会将其最后一个存的节点删掉*/
			rst.add(new ArrayList<>(list));
			list.remove(list.size()-1);
		}
		list.add(node.var);
		dfs(node.left,rst,list);
		dfs(node.right,rst,list);
		list.remove(list.size()-1);
	}
	/**
	 * 节点类
	 * var 节点值
	 * left 节点左子节点
	 * right 右子节点
	 */ 
	class Node{
		int var;
		Node left;
		Node right;
		public Node(int var){
			this.var = var;
			this.left = null;
			this.right = null;
		}
		public void setLeft(Node left) {
			this.left = left;
		}
		public void setRight(Node right) {
			this.right = right;
		}
		public int getVar() {
			return var;
		}
		public void setVar(int var) {
			this.var = var;
		}
		public Node getLeft() {
			return left;
		}
		public Node getRight() {
			return right;
		}
		
	}
 
}

运行：

非递归先序遍历：
1 2 4 8 9 5 3 6 7 
递归中序遍历：
8 4 9 2 5 1 6 3 7 
非递归中序遍历：
8 4 9 2 5 1 6 3 7 
递归后序遍历：
8 9 4 5 2 6 7 3 1 
非递归后序遍历：
8 9 4 5 2 6 7 3 1 
广度优先遍历：
1 2 3 4 5 6 7 8 9 
深度优先遍历：
[[1, 2, 4, 8], [1, 2, 4, 9], [1, 2, 5], [1, 3, 6], [1, 3, 7]]

参考：
https://blog.youkuaiyun.com/ls5718/article/details/51226674

DS二叉树--二叉树构建与遍历（含代码框架）
m0_74040903的博客
10-23 692
数据结构二叉树
二叉树的建立与遍历
10-15
按先序序列构造一棵二叉链表表示的二叉树T，并输出该T的中序遍历序列。实现提示： 1) 按先序序列建立一棵二叉树时，先构造根结点，再构造根的左子树，然后构造右子树；每棵子树又都是二叉树，所以构造一棵子树的过程与构造整棵二叉树的过程完全相同（采用递归形式直到叶子结点为止）。 2) 先序序列的输入：从键盘输入任意一棵二叉树的先序序列，用#代表空指针，如下图所示的二叉树，输入的先序序列为：ab#d##c##）。
二叉树的构建及遍历
E_kay的博客
01-27 332
编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。 例如如下的先序遍历字符串： ABC##DE#G##F### 其中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。 解题思路： 以指针方式存储，二叉树的创建从根、左、右递归创建；然后中序遍历二叉树，遍历左、根、右。 #include<stdio.h&g...
从零构建二叉树：C语言实现核心方法与最佳实践
最新发布
2401_87255690的博客
03-11 897
二叉树详解
线索二叉树构建和遍历完整版.txt
07-06
线索化二叉树之先序，中序，后序线索建树，先序，后序，中序遍历
基于C语言的二叉树构建及遍历
12-23
遍历函数是二叉树操作的核心部分，包括前序遍历、中序遍历和后序遍历。前序遍历按照“根-左-右”的顺序访问每个节点，中序遍历遵循“左-根-右”的顺序，后序遍历则是“左-右-根”的顺序。每种遍历方式在遍历算法中都...
二叉树构建，遍历.cpp
04-06
实现由先序、中序序列构造二叉树，由后序、中序序列构造二叉树，广度优先遍历以root为根结点的子树，中序遍历（递归，非递归）以root为根结点的子树
二叉树构建与遍历策略研究.zip
07-28
二叉树构建与遍历策略研究
二叉树的遍历和构建
Fibonacci的专栏
05-04 325
一.先上图，一个简单的二叉树如下：根据根节点的访问顺序，二叉树的遍历方式可分为三种：前序遍历：先访问根节点，再访问左子树，最后访问右子树中序遍历：先访问左子树，再访问根节点，最后访问右子树后序遍历：先访问左子树，再访问右子树，最后再访问根节点上面二叉树的三种遍历序列分别如下：前序遍历序列：1,2,4,5,3,6中序遍历序列：4,2,5,1,6,3后续遍历序列：4,5,2,6,3,1二.构建二叉树有...
二叉树建立及遍历
ZQYnn's blog
04-12 500
二叉树的建立以及遍历 利用递归的方式建立二叉树 并以中序遍历的方式读取数据，根据遍历二叉树的三种方式，只需要在递归时修改访问结点的元素即可。 #include <stdio.h> #include <stdlib.h> typedef struct Binode{ char data; struct Binode *Rchild ,*...
树的构建和遍历
young_Tao的博客
08-03 317
LeetCode中树的构建和遍历 这里主要介绍如何给定N，构建一棵有N个节点的完全二叉树： 给定N，那么完全二叉树的结点值从1~N。我们可以使用层序遍历的方式为队列中的结点新建子节点，这里要注意子节点的值是否超过了给定的N。 代码 #include <bits/stdc++.h> using namespace std; struct Node { int val; Node* left; Node* right; Node(int v) {
二叉树的构建与遍历
Sunny_Shu123的博客
09-27 307
根据数组创建二叉树，并对二叉树进行先序、中序和后序遍历。          代码实现： import java.util.LinkedList; import java.util.List; public class BinaryTree { private static List nodeList=null; /** * MethodName:main * De
【数据结构】二叉树的建立与遍历
weixin_45720246的博客
11-22 615
算法设计思路 二叉树的建立采用struct指针建立结点，每个结点内建两个struct指针来指向它的左右孩子，其中建立方法可采用先序，中序、后序。这里仅介绍先序建树，中序建树和后序建树实际上殊途同归。 建树代码如下 void build(Btree &t) /** * @description: 建树 * 采用先序建树，先根后左右 * @param {*Btree &t} */ { char s; sc("%c", &s); if (isdigit(
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值