二叉树理解

最新推荐文章于 2022-04-24 20:53:46 发布
最新推荐文章于 2022-04-24 20:53:46 发布
阅读量295 收藏
点赞数
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40482816/article/details/116031516
版权

二叉树 ：

二叉树结构：

class Node {
    V value;
    Node left;
    Node right;
}

什么是子树？

【子树】说明：从某个头节点开始，拿到它下面的所有节点 才 称为 子树。

如：下图中的C-D ,就不是一个子树，因为它缺少了下面的E节点。但B节点，也是一个子树。

二叉树的 先序、中序、后序。

先序：任何子树的处理顺序都是，先头结点、再左子树、然后右子树。 即：头、左、右

中序：任何子树的处理顺序都是，先左子树、再头节点、然后右子树。即：左、头、右

后序：任何子树的处理顺序都是，先左子树、再右子树、然后头节点。即：左、右、头

二叉树 遍历说明：

上图中的子树总共有7个：

1-2-3-4-5-6-7

2-4-5

3-6-7

4

5

6

7

上图二叉树遍历：对每个子树来说，都要符合指定的遍历规则。

先序遍历（头左右）：1-2-4-5-3-6-7 ，

中序遍历（左头右）：4-2-5-1-6-3-7

后序遍历（左右头）：4-5-2-6-7-3-1

二叉树代码实现

package com.example.demo.javatest.tree.binarytree;

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

import com.alibaba.fastjson.JSONObject;

/**
* 二叉树
* @author likui 
* @since  2021年4月23日 上午9:14:38
* @version 1.0
*
*/
public class BinaryTreeTest {

	/**    
	 *
	 * @Description: 二叉树节点实体类
	 * @ClassName:  Node     
	 * @version V1.0 
	 * @author: likui     
	 * @date: 2021年4月23日 上午9:16:52  
	 *
	 */ 
	public static class Node {
		
		private int value;// 头节点
		private Node left;// 左树
		private Node right;// 右树
		
		public Node(int v) {
			value = v;
		}
		
		public int getValue() {
			return value;
		}
		public void setValue(int value) {
			this.value = value;
		}
		public Node getLeft() {
			return left;
		}
		public void setLeft(Node left) {
			this.left = left;
		}
		public Node getRight() {
			return right;
		}
		public void setRight(Node right) {
			this.right = right;
		}
		
	}
	
	/**   
	 * @Title: f   
	 * @Description: 二叉树遍历，递归实现
	 * @param: @param head      
	 * @return: void      
	 * @throws   
	 */  
	public static void f(Node head) {
		if (head == null) {
			return ;
		}
		f(head.getLeft());
		f(head.getRight());
	}
	
	/**   
	 * @Title: before   
	 * @Description: 先序遍历（头左右）  ，递归实现 
	 * @param: @param head      
	 * @return: void      
	 * @throws   
	 */  
	public static void before(Node head) {
		if (head == null) {
			return ;
		}
		System.out.print(head.getValue() + "->");
		before(head.getLeft());
		before(head.getRight());
	}
	
	/**   
	 * @Title: preOrderTraverse   
	 * @Description: 先序遍历（头左右）  ，非递归实现 
	 * @param:  head      
	 * @return: void      
	 * @throws   
	 * 
	 * 弹出则打印；
	 * 如有右，压入右。
	 * 如有左，压入左。
	 */  
	public static void preOrderTraverse(Node head) {
		//  Stack是栈；特点是：先进后出。
		if (head != null) {
			Stack<Node> stack = new Stack<>();
			// 把对象 压入堆栈顶部。
			stack.push(head);
			while (!stack.empty()) {
				// pop 移除堆栈顶部的对象，并作为此函数的值返回该对象。
				head = stack.pop();
				System.out.print(head.getValue() + "->");
				// 把右树对象压入堆栈顶部。	
				if (head.getRight() != null) {
					stack.push(head.getRight());
				}
				// 把左树对象压入堆栈顶部。
				if (head.getLeft() != null) {
					stack.push(head.getLeft());
				}
			}
		}
    }
	
	/**   
	 * @Title: middle   
	 * @Description: 中序遍历 （左头右），递归实现
	 * @param: @param head      
	 * @return: void      
	 * @throws   
	 */  
	public static void middle(Node head) {
		if (head == null) {
			return ;
		}
		middle(head.getLeft());
		System.out.print(head.getValue() + "->");
		middle(head.getRight());
	}
	
	/**   
	 * @Title: inOrderTraverse   
	 * @Description:  中序遍历 （左头右），非递归实现  
	 * @param:  root      
	 * @return: void      
	 * @throws   
	 * 1、整条左边界依次入栈；
	 * 2、步骤1无法再继续，弹出节点，然后在弹出节点的右树上，继续执行步骤1
	 * 
	 */  
	public static void inOrderTraverse(Node head) {
		if (head != null) {
			Stack<Node> stack = new Stack<>();
			while (head != null || !stack.isEmpty()) {
				if (head != null) {
					stack.push(head);
					head = head.getLeft();
				} else {
					head = stack.pop();
					System.out.print(head.getValue() + "->");
					head = head.getRight();
				}
			}
		}
    }
	
	/**   
	 * @Title: after   
	 * @Description: 后序遍历 （左右头），递归实现
	 * @param:  head      
	 * @return: void      
	 * @throws   
	 */  
	public static void after(Node head) {
		if (head == null) {
			return ;
		}
		after(head.getLeft());
		after(head.getRight());
		System.out.print(head.getValue() + "->");
	}
	
	/**   
	 * @Title: postOrderTraverse   
	 * @Description: 后序遍历 （左右头），非递归实现  
	 * @param:  root      
	 * @return: void      
	 * @throws   
	 */  
	public static void postOrderTraverse(Node h) {
        if (h != null) {
        	Stack<Node> stack = new Stack<>();
        	stack.push(h);
        	Node c = null;
        	while (!stack.empty()) {
        		// 查看堆栈顶部的对象，但不从堆栈中移除它。
        		c = stack.peek();
        		if (c.getLeft() != null && h != c.getLeft() && h != c.getRight()) {
        			// c的左节点不为空，并且上次打印的节点不是c 的左节点，也不是c的右节点，即：为新节点
        			stack.push(c.getLeft());
        		} else if (c.getRight() != null && h != c.getRight()) {
        			// c的右节点不为空，并且 上次打印的节点不是 c的右节点，即 c的右节点还没处理
        			stack.push(c.getRight());
        		} else {
        			// c 的左树、右树均已处理，打印头节点
        			System.out.print(stack.pop().getValue() + "->");
        			// h 跟踪的是上次打印的节点
        			h = c;
        		}
        	}
        }
    }
	
    /**   
     * @Title: laywerTraverse   
     * @Description: 层序遍历，这个是最符合常规思维的遍历方式，
     * 				从上往下，一层一层的从左往右遍历，此处结果为1-2-3-4-5-6-7-8-9
     * @param: @param node      
     * @return: void      
     * @throws   
     */  
    public static void laywerTraverse(Node node){
 
        if(node == null) {
        	return;
        }
 
        Queue<Node> queue = new LinkedList<>();
        queue.add(node);
        Node currentNode;
        while (!queue.isEmpty()){
            currentNode = queue.poll();
            System.out.print(currentNode.getValue()+"->");
            if(currentNode.getLeft() != null){
            	queue.add(currentNode.getLeft());
            }
            if(currentNode.getRight() != null){
            	queue.add(currentNode.getRight());
            }
        }
        System.out.println();
    }
    
    // 先序方式序列化
    public static Queue<String> preSerial(Node head) {
    	Queue<String> queue = new LinkedList<>();
    	beforeSerial(head,queue);
    	return queue;
    }
    // 先序方式序列化
    private static void beforeSerial(Node head, Queue<String> queue) {
		if (head == null) {
			queue.add(null);
		} else {
			queue.add(String.valueOf(head.getValue()));
			beforeSerial(head.getLeft(), queue);
			beforeSerial(head.getRight(), queue);
		}
	}
    
    // 通过先序队列构建二叉树
    public static Node buildByBeforeQueue(Queue<String> beforeList) {
    	if (beforeList == null || beforeList.size() == 0) {
    		return null;
    	}
    	return beforeBuild(beforeList);
    }
    
    // 通过先序队列构建二叉树
    private static Node beforeBuild(Queue<String> beforeList) {
    	String value = beforeList.poll();
    	if (value == null) {
    		return null;
    	}
    	Node head = new Node(Integer.valueOf(value));
    	head.setLeft(beforeBuild(beforeList));
    	head.setRight(beforeBuild(beforeList));
		return head;
	}

	// 中序方式序列化
    private static void middleSerial(Node head, Queue<String> queue) {
    	if (head == null) {
    		queue.add(null);
    	} else {
    		middleSerial(head.getLeft(), queue);
    		queue.add(String.valueOf(head.getValue()));
    		middleSerial(head.getRight(), queue);
    	}
    }
    
    // 后序方式序列化
    private static void afterSerial(Node head, Queue<String> queue) {
    	if (head == null) {
    		queue.add(null);
    	} else {
    		afterSerial(head.getLeft(), queue);
    		afterSerial(head.getRight(), queue);
    		queue.add(String.valueOf(head.getValue()));
    	}
    }
    
    // 层级序列化
    public Queue<String> levelSerialize(Node head) {
		Queue<String> result = new LinkedList<>();
		if (head == null) {
			result.add(null);
			return result;
		}

		result.add(String.valueOf(head.getValue()));

		Queue<Node> queue = new LinkedList<>();
		queue.add(head);
		while (!queue.isEmpty()) {
			head = queue.poll();
			if (head.getLeft() != null) {
				result.add(String.valueOf(head.getLeft().getValue()));
				queue.add(head.getLeft());
			} else {
				result.add(null);
			}

			if (head.getRight() != null) {
				result.add(String.valueOf(head.getRight().getValue()));
				queue.add(head.getRight());
			} else {
				result.add(null);
			}
		}

		return result;
	}
    
    // 层级反序列化
    public Node levelBuild(Queue<String> levelList) {
		if (levelList == null || levelList.isEmpty()) {
			return null;
		}
		Node head = generateNode(levelList.poll());
		Queue<Node> queue = new LinkedList<>();
		if (head != null) {
			queue.add(head);
		}
		Node node = null;
		while (!queue.isEmpty()) {
			node = queue.poll();
			node.setLeft(generateNode(levelList.poll()));
			if (node.getLeft() != null) {
				queue.add(node.getLeft());
			}
			node.setRight(generateNode(levelList.poll()));
			if (node.getRight() != null) {
				queue.add(node.getRight());
			}
		}
		return head;
	}
    //层级反序列化
	private Node generateNode(String value) {
		if (value == null) {
			return null;
		}
		return new Node(Integer.parseInt(value));
	}
    

	/**   
     * @Title: createBinaryTree   
     * @Description: 创建二叉树
     * @param: @return      
     * @return: List<Node>      
     * @throws   
     */  
    public static List<Node> createBinaryTree(){
 
        int[] array = {1,2,3,4,5,6,7,8,9};
 
        List<Node> nodeList = new ArrayList<>();
 
        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).left =  nodeList.get(parentIndex * 2 +1);
            //右孩子
            nodeList.get(parentIndex).right =  nodeList.get(parentIndex * 2 +2);
 
        }
 
        //最后一个父节点，可能存在没有右孩子的情况，所以拿出来单独处理
        int lastParentIndex = array.length/2-1;
 
        //左孩子
        nodeList.get(lastParentIndex).left =  nodeList.get(lastParentIndex * 2 + 1);
 
        //右孩子，如果长度为奇数则建立右孩子
        if(array.length % 2 == 1){
            nodeList.get(lastParentIndex).right = nodeList.get(lastParentIndex * 2 + 2);
        }
 
        // 输出结果
//      [
//	        {"left":{"left":{"left":{"value":8},"right":{"value":9},"value":4},"right":{"value":5},"value":2},"right":{"left":{"value":6},"right":{"value":7},"value":3},"value":1},
//	        {"left":{"left":{"value":8},"right":{"value":9},"value":4},"right":{"value":5},"value":2},
//	        {"left":{"value":6},"right":{"value":7},"value":3},
//	        {"left":{"value":8},"right":{"value":9},"value":4},
//	        {"value":5},
//	        {"value":6},
//	        {"value":7},
//	        {"value":8},
//	        {"value":9}
//        ]

        return nodeList;
    }
	
    
    public static void main(String[] args) {
    	List<Node> createBinaryTree = createBinaryTree();
    	System.out.println(JSONObject.toJSON(createBinaryTree));
    	
    	Node node = createBinaryTree.get(0);
    	System.out.println(JSONObject.toJSON(JSONObject.toJSON(node)));
    	// 先序遍历
    	System.out.println("先序：------------------------------------------------");
    	before(node);
    	System.out.println();
    	preOrderTraverse(node);
    	System.out.println();
    	// 中序遍历
    	System.out.println("中序：-----------------------------------------------");
    	middle(node);
    	System.out.println();
    	inOrderTraverse(node);
    	System.out.println();
    	// 后序遍历
    	System.out.println("后序：-----------------------------------------------");
    	after(node);
    	System.out.println();
    	postOrderTraverse(node);
    	
    	System.out.println();
    	// 层序遍历
    	System.out.println("层序：-----------------------------------------------");
    	laywerTraverse(node);
	}
	
}

输出结果：

{"left":{"left":{"left":{"value":8},"right":{"value":9},"value":4},"right":{"value":5},"value":2},"right":{"left":{"value":6},"right":{"value":7},"value":3},"value":1}
先序：------------------------------------------------
1->2->4->8->9->5->3->6->7->
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、 满二叉树（Full Binary Tree）

一棵满二叉树就是高度为k，且拥有(2^k)-1个节点的二叉树，一棵满二叉树每个节点，要么都有两棵子树，要么都没有子树；而且每一层所有的节点之间必须要么都有两棵子树，要么都没子树。

  • 2、完全二叉树（Complete Binary Tree）

完全二叉树是一颗特殊的二叉树，它遵循以下规则：
假设完全二叉树高度为k，则完全二叉树需要符合以下两点：
1）所有叶子节点都出现在k层或k-1层，并且从1~k-1层必须达到最大节点数。
2）第k层可以是不满的，但是第k层的所有节点必须集中在最左边。

 

 

炎升
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
二叉树的子树和子结构 c++
nepenthe_csdn的博客
08-28 5191
鉴于中兴笔试中二叉树的子树以及剑指offer中二叉树的子结构问题，现总结如下： 什么是二叉树的子结构及子树？ 子树的意思是包含了一个结点，就得包含这个结点下的所有节点，一棵大小为n的二叉树有n个子树，就是分别以每个结点为根的子树。子结构的意思是包含了一个结点，可以只取左子树或者右子树，或者都不取。 1、输入两棵二叉排序树A，B，判断B是不是A的子树。（ps：我们约定空树不是任意一个树的子
链表Node，二叉树TreeNode， 广度优先搜索中压入队列的Node， 字典树中的Node
qq_31617121的博客
03-25 2020
链表Node这么写 class Node { int val; Node next; public Node(int val) { this.val = val; } } Node节点中有个成员变量val，是整型的，代表这个节点的值。next指针指向的是下一个节点。 二叉树TreeNode class TreeNode { int...
elasticsearch节点脱离集群 分片控制
zhengxgs的博客
12-30 7566
Rebalancing操作，延迟分配
java实现二叉树的Node节点定义,并手撕8种遍历
热门推荐
默默的笔记
10-08 3万+
最近准备秋招面试，发现二叉树这种可以无限扩展知识点来虐别人的数据结构，很受面试官的青睐。 如果掌握的不好，会直接死在一面哦。 怕吗？当你原理、思想，内部结构通通明白，分分钟手撕代码的程度，还怕吗？ 本篇文章就从用java的思想和程序从最基本的怎么将一个int型的数组变成Node树状结构说起，再到递归前序遍历，递归中序遍历，递归后序遍历，非递归前序遍历，非递归前序遍历，非递归前序遍历，到最后的广度优...
二叉树基础及应用
laokdidiao的专栏
07-08 7857
二叉树基础： 刚看到堆排序，顺便记录一下关于树的一些基本概念： 前言 前面介绍的栈、队列都是线性结构(linear structure)。而树是非线性结构(non-linear structure)。因此，树中的元素之间一般不存在类似于线性结构的一对一的关系，更多地表现为多对多的关系。直观地看，它是数据元素(在树中称为节点)按分支关系组织起来的结构。显然，树形结构是比线性结构
VC++ 二叉树遍历及二叉树生成 理解
10-25
1、对二叉树先、中、后根遍历理解 2、使用C++实现根据给出的序列生成对应的二叉树 3、MFC 演示二叉树生成过程
非常适合小白理解的C++二叉树代码
最新发布
05-20
二叉树 非常适合小白理解的C++二叉树代码 非常适合小白理解的C++二叉树代码 非常适合小白理解的C++二叉树代码 非常适合小白理解的C++二叉树代码 非常适合小白理解的C++二叉树代码
深入理解二叉树的非递归遍历
09-05
本篇文章是对二叉树的非递归遍历进行了详细的分析介绍，需要的朋友参考下
部分二叉树总结
02-14
自己根据资料对二叉搜索树，B树,红黑树等的基本梳理和总结，一张脑图就能理解，费了一些功夫弄出来的，手里没多少分的就不要下了
二叉树的实现
11-19
这是二叉树的简介和实现，非常适合初学者使用。代码附有详细注释，便于理解。
二叉树（一）
TaskaNon的博客
03-27 898
一 概念： 满二叉树：每一个结点或者是一个分支结点，并恰好有两个非空子结点；或者是叶结点。 完全二叉树：从根结点起，每一层从左至右填充。 二叉树的性质： <1> 二叉树中，第i层的节点最多有2(i-1)个。 <2> 深度为k的二叉树最多有2k-1个节点。 <3> 二叉树中，叶子节点树为N1个，度为2的节点有N2个，那么N1=N2+1。 <4> 具有
如何创建一个简单的二叉树（TreeNode）？
weixin_39309402的博客
10-17 9367
我们都知道，数据结构最典型的就是数组和链表，在《算法图解》一书中，详细介绍了数组和链表的优缺点： 数组查询快（下标），但删除或者插入就比较慢（遍历） 链表与之相反，删除和插入元素很快，但查找很慢 所以二叉树就应运而生了，它结合二者的优点，取二家之长，但是在实际编程中，大多时候，根本用不到二叉树（实际编程中，我从来没用过二叉树，但是面试可能会问啊，所以趁有空学习总结下），网上找了一下二叉树的应用场...
全网最全二叉树介绍
a1085653724的博客
04-24 1111
1，树型结构 1.1概念： 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看 起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。（进行查找和搜索时用） 它具有以下的特点： ①有一个特殊的节点，称为根节点，根节点没有前驱节点 ②除根节点外，其余节点被分成M(M > 0)个互不相交的集合T1、T2、......、Tm，其中每一个集合 Ti (1 <= i <= m) 又是一棵与树类似的子树。每棵子树的根节点有且只有一
深度linux node,二叉树的深度_Linux编程_Linux公社-Linux系统门户网站
weixin_36165398的博客
05-14 60
输入一棵二叉树的根结点，求该树的深度，从根结点到叶结点依次经过的结点(含根，叶结点)形成树的一条路径，最长路径的长度为树的深度#include using namespace std;struct BinaryTreeNode{int data;struct BinaryTreeNode *lchild;struct BinaryTreeNode *rchild;};typedef struct ...
JS 数据结构，二叉搜索树
Wu hao's blog
09-18 211
前言： 这里我们来了解 “ 树 ” 这种常见的数据结构。在我们有数组，链表，哈希表等后，为什么会产生树这种数据结构呢 ？ 数组的优点 ：数组的主要优点是根据下标值访问效率会高很多。 数组的缺点 ：在根据元素查找对应的位置时，需要先对数组进行排序，生成有序数组，才能提高查找效率（比较好的方式就是，先对数组进行排序，在进行二分查找。）。另外数组在插入和删除操作时，需要大量的位移操作，效率低。 链表优点 ：链表的插入和删除效率都很高。 链表缺点 ：查找的效率很低，需要从头开始已次访问链表中的每个数据项
二叉树最强总结(python实现)
coder_Gray的博客
06-04 4744
这篇文章总结了关于二叉树的创建和各种遍历方式。 二叉树的创建方式 通过层次遍历顺序创建 先序遍历顺序(带上叶子结点标识符)创建 先序顺序+中序顺序 中序顺序+后序顺序 二叉树的递归方式 先序遍历(递归+非递归) 中序遍历(递归+非递归) 后序遍历(递归+非递归) 广度优先遍历(BFS) 首先来定义一下节点的结构 class Node(): def __init__(s...
populating-next-right-pointers-in-each-node(填充每个节点中右下角的指针)
ShuJk的博客
03-27 195
1.题目 给定一个二叉树 struct TreeLinkNode { TreeLinkNode *left; TreeLinkNode *right; TreeLinkNode * next; } 填充每个下一个指针指向其下一个右侧节点。 如果没有下一个正确的节点，则应将下一个指针设置为NULL。 最初，所有下一个指针都设置...
深入理解二叉树
壮飞的博客
05-15 744
二叉树 本文讲解二叉树的存储结构、树的创建、树的三种遍历方式、树的深度、左右子树交换 二叉树是什么样子的？如下图 二叉树的结构 这样的一棵二叉树应该用什么结构来存储呢？ 二叉树是由各个结点组成的，只要知道根节点，那么就可以对整个二叉树做任何操作了 二叉树的结点有数据域、指向左子树的指针域、指向右子树的指针域 //定义节点的结构 typedef struct BiNo...
怎么理解二叉树中序遍历
07-25
二叉树的中序遍历是一种遍历方式，它按照左子树、根节点、右子树的顺序来遍历二叉树。具体操作如下： 1. 如果当前节点为空，则返回。 2. 对当前节点的左子树进行中序遍历，即递归调用中序遍历函数。 3. 访问当前节点。 4. 对当前节点的右子树进行中序遍历，即递归调用中序遍历函数。 中序遍历可以帮助我们按照从小到大的顺序访问二叉搜索树的节点。在实际应用中，中序遍历也常用于查找二叉搜索树中某个节点的前驱或后继节点。 例如，对于以下二叉树： 1 / \ 2 3 / \ 4 5 中序遍历结果为：4 -> 2 -> 5 -> 1 -> 3

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值