树和二叉树

最新推荐文章于 2024-07-24 17:54:05 发布
最新推荐文章于 2024-07-24 17:54:05 发布
阅读量195 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 二叉树 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43319635/article/details/104532685
版权

一、树的基本概念

树是由一个集合以及在该集合上定义的一种关系构成的。集合中的关系称的结点，所定义的关系为父子关系最上层为根节点树是n（n>=o)个结点的有限集
在这里插入图片描述
a.一颗空树，b.有一个根节点的树，c.有许多子结点

结点的度：结点拥有子结点的数目
树的度：树内各节点最大的度数
在这里插入图片描述
树的深度：树中结点的最大层树
在这里插入图片描述
有序树：各节点从左到右有次序
在这里插入图片描述

二、二叉树

每个结点的度都不超过二的有序树，称为二叉树
在这里插入图片描述
满二叉树：高度为并且有个2＾（k+1）-1结点的二叉树，每层的结点都达到最大数
在这里插入图片描述
完全二叉树：在一棵满二叉树中，在最下层最右侧起去点相邻的叶子结点得到的二叉树
在这里插入图片描述
满二叉树必为完全二叉树，反之不一定
二叉树的性质：
1.在二叉树的第i层上最多有2^(i-1) 个结点（根是第一层）
2.高度为h的二叉树最多有2^h -1个节点
3.对于任何一个二叉树，如果其终端节点数为n,度为2 的结点数为m，则n=m+1
4.如果一颗二叉树有n个结点的完全二叉树进行编号，则对任一结点（1<=i<=n)
5.若i=1,则i是二叉树的根、、
6.如果2i>n,则结点i无左孩子，否则其左孩子为2i
7.如果2i+1>n，则结点i无右孩子，否则其右孩子为2i+1

三、叉树的存储结构

１．顺序存储结构
对于满二叉树和完全二叉树来说，可以将其数据元素筑层放到一组连续的存储单元
在这里插入图片描述
如果不是满二叉树，则比较浪费空间
在这里插入图片描述
2.链式存储结构
若将其采用链式存储，则只需从树的根节点开始，将各个节点及其左右孩子使用链表存储即可。因此，图 1 对应的链式存储结构如图 2 所示：

二叉树链式存储结构示意图
在这里插入图片描述

二叉树遍历

遍历：按着某种次序访问树中所以二叉树，且每个节点恰好访问一次。人为的将非线性化线性化。
先序遍历ＤＬＲ：根　左　右
中序遍历ＬＤR:左子树　根　右子树
后序遍历ＬRＤ:左　右　根
在这里插入图片描述

Node.java

/**
 * 
 */
package com.liang.datastructure.btree;

/**
 * 二叉树链表节点
 * @author Administrator
 *
 */
public class Node {
	private Node leftChild;//左子树引用
	private Object data;
	private Node rightChild;
	
	
	public Node(Object data) {
		super();
		this.data = data;
	}

	public Node(Node leftChild, Object data, Node rightChild) {
		super();
		this.leftChild = leftChild;
		this.data = data;
		this.rightChild = rightChild;
	}
	public Node getLeftChild() {
		return leftChild;
	}
	public void setLeftChild(Node leftChild) {
		this.leftChild = leftChild;
	}
	public Object getData() {
		return data;
	}
	public void setData(Object data) {
		this.data = data;
	}
	public Node getRightChild() {
		return rightChild;
	}
	public void setRightChild(Node rightChild) {
		this.rightChild = rightChild;
	}

	@Override
	public String toString() {
		return "Node [leftChild=" + leftChild + ", data=" + data + ", rightChild=" + rightChild + "]";
	}
	
	
	
}

BinaryTree.java

package com.liang.datastructure.btree;
/**
 * 二叉树接口
 * 可以有不同的实现类，每个类可以使用不同的存储结构，比如顺序结构、链式结构
 * @author Administrator
 *
 */
public interface BinaryTree {
	/**
	 * 是否空树
	 * @return
	 */
	public boolean isEmpty();
	/**
	 * 树结点数量
	 * @return
	 */
	public int size();
	
	/**
	 * 获取二叉树的高度
	 * @return
	 */
	public int getHeight();
	/**
	 * 查询指定值的结点
	 * @param value
	 * @return
	 */
	public Node findKey(int value); // 查找
	/**
	 * 前序递归遍历
	 */
	public void preOrderTraverse(); 
	/**
	 * 中序遍历递归操作
	 */
	public void inOrderTraverse();  	
	/**
	 * 后序遍历递归操作
	 */
	public  void postOrderTraverse();
	/**
	 * 后序遍历递归操作
	 * @param node  树根结点
	 */
	public  void postOrderTraverse(Node node); 
	/**
	 * 中序遍历非递归操作
	 * 1）对于任意节点current，若该节点不为空则将该节点压栈，并将左子树节点置为current，重复此操作，直到current为空。 
	 * 2）若左子树为空，栈顶节点出栈，访问节点后将该节点的右子树置为current
	 * 3) 重复1、2步操作，直到current为空且栈内节点为空。 
	 */
	public void inOrderByStack();
	/**
	 *   前序遍历非递归操作
	 *   1）对于任意节点current，若该节点不为空则访问该节点后再将节点压栈，并将左子树节点置为current，重复此操作，直到current为空。 
	 *   2）若左子树为空，栈顶节点出栈，将该节点的右子树置为current 
	 *   3) 重复1、2步操作，直到current为空且栈内节点为空。
	 */
	public  void preOrderByStack(); 
	/**
	 * 后序遍历非递归操作
	 * 1）对于任意节点current，若该节点不为空则访问该节点后再将节点压栈，并将左子树节点置为current，重复此操作，直到current为空。 
	 * 2）若左子树为空，取栈顶节点的右子树，如果右子树为空或右子树刚访问过，则访问该节点，并将preNode置为该节点 
	 * 3) 重复1、2步操作，直到current为空且栈内节点为空。 
	 */
	public  void postOrderByStack(); 
	
	/**
	 * 按照层次遍历二叉树
	 */
	public void levelOrderByQueue();
}

LinkedBinaryTree.java

/**
 * 
 */
package com.liang.datastructure.btree;

import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;

/**

 * @author Administrator
 *链式实现类
 */
public class LinkedBinaryTree implements BinaryTree{
	private Node root;
	
	
	
	public LinkedBinaryTree() {
		super();
	}

	public LinkedBinaryTree(Node root) {
		super();
		this.root = root;
	}

	@Override
	public boolean isEmpty() {
		// TODO 自动生成的方法存根
		return root == null;
	}

	@Override
	public int size() {
		return this.size(root);
	}
	private int size(Node node) {
		if(node==null) {
			return 0;
		}else {
			//左子树节点数
			int l = this.size(node.getLeftChild());
			//右子树节点数
			int r=this.size(node.getRightChild());
			return l+r+1;
		}
	}

	@Override
	public int getHeight() {
		
		return getHeight(root);
	}
	private int getHeight(Node node) {
		if(node==null) {
			//System.out.println("-------------");
			return 0;
		}else {
			int l = this.getHeight(node.getLeftChild());
			//System.out.print("l值:"+l+"  ");
			int r=this.getHeight(node.getRightChild());
			//System.out.print("r值:"+r+"  ");
			return l>r ? l+1:r+1;
		}
		
	}
	@Override
	public Node findKey(int value) {
		return findKey(value,root);
	}
	public Node findKey(Object value,Node root) {
		if(root == null){//递归结束条件1：结点为空，可能是整个树的根节点，也可能是递归调用中叶子节点中左孩子和右孩子
			return null;
		}else if(root != null && root.getData() == value){//递归的结束条件2：找到了
			return root;
		}else {//递归体
			Node node1 = this.findKey(value, root.getLeftChild());
			Node node2 = this.findKey(value, root.getRightChild());
			if(node1 != null && node1.getData() == value){
				return node1;
			}else if(node2 != null && node2.getData() == value){
				return node2;
			}else{
				return null;
			}
		}
	} 
	@Override
	public void preOrderTraverse() {
		if(root != null){
			//1.输出根结点的值
			System.out.print(root.getData()+"  ");
			//2.对左子树进行先序遍历
			//构建一个二叉树，根是左子树的根
			BinaryTree  leftTree = new LinkedBinaryTree(root.getLeftChild());
			leftTree.preOrderTraverse();
			//对右子树进行先序遍历
			//3.构建一个二叉树，根是右子树的根
			BinaryTree  rightTree = new LinkedBinaryTree(root.getRightChild());
			rightTree.preOrderTraverse();
		}
	}

	@Override
	public void inOrderTraverse() {
		System.out.println("中序遍历:");
		inOrderTraverse(root);
		System.out.println();
		
	}
	private void inOrderTraverse(Node root) {
		if(root!=null) {
		this.inOrderTraverse(root.getLeftChild());
		System.out.print(root.getData()+"  ");
		this.inOrderTraverse(root.getRightChild());
		}
	}

	@Override
	public void postOrderTraverse() {
		System.out.println("后序遍历:");
		postOrderTraverse(root);
		System.out.println();
	}

	@Override
	public void postOrderTraverse(Node node) {
		if(node!=null) {
			this.postOrderTraverse(node.getLeftChild());
			this.postOrderTraverse(node.getRightChild());
			System.out.print(node.getData()+"  ");
		}
	}

	@Override
	public void inOrderByStack() {
		System.out.println("中序非递归遍历:");
		// 创建栈
		Deque<Node> stack = new LinkedList<Node>();
		Node current = root;
		while (current != null || !stack.isEmpty()) {
			while (current != null) {
				stack.push(current);
				current = current.getLeftChild();
			}

			if (!stack.isEmpty()) {
				current = stack.pop();
				System.out.print(current.getData() + " ");
				current = current.getRightChild();
			}
		}
		System.out.println();	
		
	}

	@Override
	public void preOrderByStack() {
		// TODO 自动生成的方法存根
		
	}

	@Override
	public void postOrderByStack() {
		// TODO 自动生成的方法存根
		
	}

	@Override
	public void levelOrderByQueue() {
		System.out.println("按照层次遍历二叉树");
		if(root == null) return;
	    Queue<Node> queue = new LinkedList<Node>() ;
	    queue.add(root);
	    while(queue.size() != 0)
	    {
	        int len = queue.size();
	        for(int i=0;i <len; i++)
	        {
	        	Node temp = queue.poll();
	            System.out.print(temp.getData()+" ");
	            if(temp.getLeftChild() != null)  queue.add(temp.getLeftChild());
	            if(temp.getRightChild() != null) queue.add(temp.getRightChild());
	        }
	    }
	    
	    System.out.println();
		
	}

}

测试

/**
 * 
 */
package com.liang.datastructure.btree;

/**
 * @author Administrator
 *
 */
public class Test {
	public static void main(String[] args) {
		//创建一个二叉树
		Node node5=new Node(5);
		Node node4 = new Node(null, 4, node5);
		Node node7 = new Node(7);
		Node node6 = new Node(null, 6, node7);
		Node node3 = new Node(3);
		Node node2 = new Node(node3, 2, node6);
		Node node1 = new Node(node4, 1, node2);
		
		BinaryTree btree=new LinkedBinaryTree(node1);
				//判断二叉树是否为空
				System.out.println(btree.isEmpty());
				
				//先序遍历递归  1  4  5  2  3  6  7
				System.out.println("先序遍历");
				btree.preOrderTraverse();
				System.out.println();
				
				//中序遍历递归  4  5  1  3  2  6  7
				btree.inOrderTraverse();
				
				//后序遍历递归  5  4  3  7  6  2  1 
				btree.postOrderTraverse();
				
				System.out.println(btree.getHeight());
				System.out.println(btree.size());
				//中序遍历非递归（借助栈） 4  5  1  3  2  6  7
				//btree.inOrderByStack();
				btree.levelOrderByQueue();
	}
}
Insane'
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode 例题精讲 | 11 二叉树转化为链表：二叉树遍历中的相邻结点
程序员吴师兄的博客
04-16 496
点击关注上方“五分钟学算法”，设为“置顶或星标”，第一时间送达干货。转自面向大象编程，作者nettee本期例题：LeetCode 98. Validate Binary Search T...
树和二叉树对比
自己的选择，无论是否正确，请坚持下去，黎明就在下一刻。
09-08 3233
树和二叉树都有一个树字，从结构上来说，都是树状结构，但是它们之间的区别是什么呢？那就拿两者的特点来说一说把。 首先是 树 先看一下树的基本概念和它的一些术语： Root：根节点。 描述：树的顶部节点。 Child：子节点。 描述：离开根节点时直接连接到另一个节点的节点。 Leaf ：叶子节点。 描述：没有子节点的节点 Edge： 边。 描述：一个节点与另一个节点之间的连接。 Path：路径。 描述：连接节点和子节点的节...
树和二叉树源码
11-08
在计算机科学领域，树和二叉树是两种重要的数据结构，它们在许多应用中发挥着核心作用，如文件系统、数据库索引、编译器设计等。本篇将深入探讨这些概念及其相关的算法。 首先，我们要理解“树”这一概念。树是一种...
python数据结构树和二叉树简介
01-20
一、树的定义 树形结构是一类重要的非线性结构。树形结构是结点之间有分支，并具有层次关系的结构。...它或者是空集，或者是由一个根和称为左、右子树的两个不相交的二叉树组成。特点：（1）二叉树是有序树，
树和二叉树课件
01-31
此外，满二叉树和完全二叉树有特殊的数组表示方法，可以节省空间并优化某些操作。 课件中还涉及到了二叉树的实现，包括创建、插入、删除等基本操作。例如，二叉搜索树（Binary Search Tree）是一种特殊的二叉树，...
c语言（7.23）
fhgfyrsg的博客
07-23 399
【代码】c语言（7.23）
数据结构---二叉树
weixin_47808575的博客
07-22 333
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 764
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
【数据结构-前缀和】力扣2550.统计范围内的元音字符串数
sjsjs11的博客
07-22 511
计算前缀和数组的时间是 O(n)，然后计算 q 个查询的答案，计算每个查询的答案的时间是 O(1)，因此时间复杂度是 O(n+q)。输入：words = [“aba”,“bcb”,“ece”,“aa”,“e”], queries = [[0,2],[1,4],[1,1]]输入：words = [“a”,“e”,“i”], queries = [[0,2],[0,1],[2,2]]查询 [1,4] 结果为 3（字符串 “ece”、“aa”、“e”）。返回结果 [2,3,0]。输出：[3,2,1]
数据结构：（1）线性表
最新发布
weixin_71751116的博客
07-24 1019
概念：零个或多个数据元素的有限序列元素之间是有顺序了。如果存在多个元素，第一个元素无前驱最后一个没有后继其他的元素只有一个前驱和一个后继。当线性表元素的个数n（n>=0）定义为线性表的长度，当n=0时，为空表。在非空的表中每个元素都有一个确定的位置，如果a1是第一个元素，那么an就是第n个元素。线性表的常规操作 ADTchar sex;int age;int score;}DATATYPE;//数组名int tlen;
数据结构之判断完全二叉树详解与示例（C，C++）
qq_35320456的博客
07-23 382
通过上述C和C++的实现示例，我们可以看到判断一个二叉树是否为完全二叉树的基本方法是使用层序遍历。在遍历过程中，我们通过设置一个标记来区分节点是否应该为叶子节点，从而判断二叉树是否满足完全二叉树的条件。这种方法的时间复杂度为O(n)，其中n是二叉树中节点的数量，因为每个节点最多只会被访问一次。在实际应用中，完全二叉树由于其特殊的结构，常用于堆的实现，因为它可以在数组中有效地表示，同时保持堆的操作效率。理解并掌握判断完全二叉树的方法，对于深入理解二叉树结构和相关算法有重要意义。
数据结构（特殊二叉树－线索二叉树）
weixin_65029285的博客
07-22 359
链式二叉树中有很多的空指针，可以让这些空指针指向前一个节点\后一个节点，从而在有序遍历（中序遍历）二叉树时，不需要使用递归而通过循环即可以完成，并且效率要比递归快得多。首先需要有一颗搜索二叉树，然后通过中序遍历并生成线索，通过检查右子树是否为空来决定是否生成线索，让右子树指向下一个节点。bool lflag;// 左子树是否是线索 为真时，左子树是线索 指向前一个节点。bool rflag;// 右子树是否是线索 为真时，右子树是线索 指向下一个节点。
华清数据结构day5 24-7-22
m0_62859255的博客
07-22 387
【代码】华清数据结构day5 24-7-22。
数据结构（1）（顺序表）
qq_54094530的博客
07-23 840
数据结构相互之间存在一种或多种特定关系的数据元素的集合。逻辑结构集合，所有数据在同一个集合中，关系平等。（数组中的每一个int）线性，数据和数据之间是一对一的关系（队列，链表，数组（线性表的一种体现））树， 一对多（高效）图，多对多物理结构(在内存当中的存储关系)顺序存储，数据存放在连续的存储单位中。逻辑关系和物理关系一致链式，数据存放的存储单位是随机或任意的，可以连续也可以不连续。struct Per 数据元素char name;//数据项（变量）
数据结构之栈详解
m0_73634434的博客
07-23 444
栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。，相对而言数组的结构实现更优一些。栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。整合以上我们来实现栈，下面是实现栈的完整代码。压栈：栈的插入操作叫做进栈/插栈/入栈，这里定长的静态栈的结构，实现中一般不实用。所以我们主要实现下面的支持动态增长的栈。出栈：栈的删除操作叫做出栈。->6. 查看栈中有没有元素。栈所需要实现的一些功能。->5. 查看栈的大小。栈的实现一般可以使用。->4. 删除栈元素。
树和二叉树的概念与应用
"该资源为‘树和二叉树.ppt’，涵盖了树的基本概念、二叉树的性质、遍历、二叉树与树的转换、线索二叉树、赫夫曼树及其编码等内容，适合学习数据结构的IT专业人员。" 在计算机科学中，树是一种非常重要的数据结构，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值