六 二叉树

最新推荐文章于 2022-05-22 08:06:01 发布
最新推荐文章于 2022-05-22 08:06:01 发布
阅读量493 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41375318/article/details/105889859
版权

六 二叉树

树结构概述

在这里插入图片描述
为什么使用树？其中一个原因：

  • 顺序表查找方便，插入删除麻烦
  • 链表，插入删除简单，但是查找麻烦
  • 树综合考虑了以上问题，他的修改和查找能力比较中和。

基本概念：
在这里插入图片描述

二叉树的概述

在这里插入图片描述
在这里插入图片描述
能连续数满就是完全二叉树
在这里插入图片描述

创建二叉树

  • 二叉树的五种形态：

在这里插入图片描述

package demo5;

public class Node {
	//节点的权
	int value;
	//左儿子
	Node leftNode;
	//右儿子
	Node rightNode;
	
	public Node(int value) {
		this.value=value;
	}
	
	//设置左儿子
	public void setLeftNode(Node leftNode) {
		this.leftNode = leftNode;
	}
	//设置右儿子
	public void setRightNode(Node rightNode) {
		this.rightNode = rightNode;
	}
	
	//前序遍历
	public void frontShow() {
		//先遍历当前节点的内容
		System.out.println(value);
		//左节点
		if(leftNode!=null) {
			leftNode.frontShow();
		}
		//右节点
		if(rightNode!=null) {
			rightNode.frontShow();
		}
	}

	//中序遍历
	public void midShow() {
		//左子节点
		if(leftNode!=null) {
			leftNode.midShow();
		}
		//当前节点
		System.out.println(value);
		//右子节点
		if(rightNode!=null) {
			rightNode.midShow();
		}
	}

	//后序遍历
	public void afterShow() {
		//左子节点
		if(leftNode!=null) {
			leftNode.afterShow();
		}
		//右子节点
		if(rightNode!=null) {
			rightNode.afterShow();
		}
		//当前节点
		System.out.println(value);
	}

	//前序查找
	public Node frontSearch(int i) {
		Node target=null;
		//对比当前节点的值
		if(this.value==i) {
			return this;
		//当前节点的值不是要查找的节点
		}else {
			//查找左儿子
			if(leftNode!=null) {
				//有可能可以查到，也可以查不到，查不到的话，target还是一个null
				target = leftNode.frontSearch(i);
			}
			//如果不为空，说明在左儿子中已经找到
			if(target!=null) {
				return target;
			}
			//查找右儿子
			if(rightNode!=null) {
				target=rightNode.frontSearch(i);
			}
		}
		return target;
	}
	
	//删除一个子树
	public void delete(int i) {
		Node parent = this;
		//判断左儿子
		if(parent.leftNode!=null&&parent.leftNode.value==i) {
			parent.leftNode=null;
			return;
		}
		//判断右儿子
		if(parent.rightNode!=null&&parent.rightNode.value==i) {
			parent.rightNode=null;
			return;
		}
		
		//递归检查并删除左儿子
		parent=leftNode;
		if(parent!=null) {
			parent.delete(i);
		}
		
		//递归检查并删除右儿子
		parent=rightNode;
		if(parent!=null) {
			parent.delete(i);
		}
	}

}


package demo5;

public class BinaryTree {

	Node root;
	
	//设置根节点
	public void setRoot(Node root) {
		this.root = root;
	}
	
	//获取根节点
	public Node getRoot() {
		return root;
	}

	public void frontShow() {
		if(root!=null) {
			root.frontShow();
		}
	}

	public void midShow() {
		if(root!=null) {
			root.midShow();
		}
	}

	public void afterShow() {
		if(root!=null) {
			root.afterShow();
		}
	}

	public Node frontSearch(int i) {
		return root.frontSearch(i);
	}

	public void delete(int i) {
		if(root.value==i) {
			root=null;
		}else {
			root.delete(i);
		}
	}
	


package demo5;

public class TestBinaryTree {

	public static void main(String[] args) {
		//创建一颗树
		BinaryTree binTree = new BinaryTree();
		//创建一个根节点
		Node root = new Node(1);
		//把根节点赋给树
		binTree.setRoot(root);
		//创建一个左节点
		Node rootL = new Node(2);
		//把新创建的节点设置为根节点的子节点
		root.setLeftNode(rootL);
		//创建一个右节点
		Node rootR = new Node(3);
		//把新创建的节点设置为根节点的子节点
		root.setRightNode(rootR);
		//为第二层的左节点创建两个子节点
		rootL.setLeftNode(new Node(4));
		rootL.setRightNode(new Node(5));
		//为第二层的右节点创建两个子节点
		rootR.setLeftNode(new Node(6));
		rootR.setRightNode(new Node(7));
		//前序遍历树
		binTree.frontShow();
		System.out.println("===============");
		//中序遍历
		binTree.midShow();
		System.out.println("===============");
		//后序遍历
		binTree.afterShow();
		System.out.println("===============");
		//前序查找
		Node result = binTree.frontSearch(5);
		System.out.println(result);
		
		System.out.println("===============");
		//删除一个子树
		binTree.delete(4);
		binTree.frontShow();
		
	}

}

遍历二叉树

在这里插入图片描述

A：根节点、B：左节点、C：右节点，前序顺序是ABC（根节点排最先，然后同级先左后右）；中序顺序是BAC(先左后根最后右）；后序顺序是BCA（先左后右最后根）。

  • 实例：

在这里插入图片描述

二叉树中节点的查找

删除二叉树的子树

顺序存储的二叉树的概述

  • 顺序存储二叉树

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

但其实

在这里插入图片描述
在这里插入图片描述

顺序存储的二叉树的遍历

package demo6;

public class ArrayBinaryTree {

	int[] data;
	
	public ArrayBinaryTree(int[] data) {
		this.data=data;
	}
	
	public void frontShow() {
		frontShow(0);
	}
	
	//前序遍历
	public void frontShow(int index) {
		if(data==null||data.length==0) {
			return;
		}
		//先遍历当前节点的内容
		System.out.println(data[index]);
		//2*index+1:处理左子树
		if(2*index+1<data.length) {
			frontShow(2*index+1);
		}
		//2*index+2:处理右子树
		if(2*index+2<data.length) {
			frontShow(2*index+2);
		}
	}
	
}


package demo6;

public class TestArrayBinaryTree {

	public static void main(String[] args) {
		int[] data = new int[] {1,2,3,4,5,6,7};
		ArrayBinaryTree tree = new ArrayBinaryTree(data);
		//前序遍历
		tree.frontShow();
	}

}

常用排序算法之堆排序

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package demo4;

import java.util.Arrays;

public class HeapSort {
	
	public static void main(String[] args) {
		int[] arr = new int[] {9,6,8,7,0,1,10,4,2};
		heapSort(arr);
		System.out.println(Arrays.toString(arr));
	}
	
	public static void heapSort(int[] arr) {
		//开始位置是最后一个非叶子节点，即最后一个节点的父节点
		int start = (arr.length-1)/2;
		//调整为大顶堆
		for(int i=start;i>=0;i--) {
			maxHeap(arr, arr.length, i);
		}
		//先把数组中的第0个和堆中的最后一个数交换位置，再把前面的处理为大顶堆
		for(int i=arr.length-1;i>0;i--) {
			int temp = arr[0];
			arr[0]=arr[i];
			arr[i]=temp;
			maxHeap(arr, i, 0);
		}
	}
	
	public static void maxHeap(int[] arr,int size,int index) {
		//左子节点
		int leftNode = 2*index+1;
		//右子节点
		int rightNode = 2*index+2;
		int max = index;
		//和两个子节点分别对比，找出最大的节点
		if(leftNode<size&&arr[leftNode]>arr[max]) {
			max=leftNode;
		}
		if(rightNode<size&&arr[rightNode]>arr[max]) {
			max=rightNode;
		}
		//交换位置
		if(max!=index) {
			int temp=arr[index];
			arr[index]=arr[max];
			arr[max]=temp;
			//交换位置以后，可能会破坏之前排好的堆，所以，之前的排好的堆需要重新调整
			maxHeap(arr, size, max);
		}
	}

}

线索二叉树的概述

在这里插入图片描述

线索二叉树代码实现

package demo7;

public class ThreadedNode {
	//节点的权
	int value;
	//左儿子
	ThreadedNode leftNode;
	//右儿子
	ThreadedNode rightNode;
	//标识指针类型
	int leftType;
	int rightType;
	

	public ThreadedNode(int value) {
		this.value=value;
	}
	
	//设置左儿子
	public void setLeftNode(ThreadedNode leftNode) {
		this.leftNode = leftNode;
	}
	//设置右儿子
	public void setRightNode(ThreadedNode rightNode) {
		this.rightNode = rightNode;
	}
	
	//前序遍历
	public void frontShow() {
		//先遍历当前节点的内容
		System.out.println(value);
		//左节点
		if(leftNode!=null) {
			leftNode.frontShow();
		}
		//右节点
		if(rightNode!=null) {
			rightNode.frontShow();
		}
	}

	//中序遍历
	public void midShow() {
		//左子节点
		if(leftNode!=null) {
			leftNode.midShow();
		}
		//当前节点
		System.out.println(value);
		//右子节点
		if(rightNode!=null) {
			rightNode.midShow();
		}
	}

	//后序遍历
	public void afterShow() {
		//左子节点
		if(leftNode!=null) {
			leftNode.afterShow();
		}
		//右子节点
		if(rightNode!=null) {
			rightNode.afterShow();
		}
		//当前节点
		System.out.println(value);
	}

	//前序查找
	public ThreadedNode frontSearch(int i) {
		ThreadedNode target=null;
		//对比当前节点的值
		if(this.value==i) {
			return this;
		//当前节点的值不是要查找的节点
		}else {
			//查找左儿子
			if(leftNode!=null) {
				//有可能可以查到，也可以查不到，查不到的话，target还是一个null
				target = leftNode.frontSearch(i);
			}
			//如果不为空，说明在左儿子中已经找到
			if(target!=null) {
				return target;
			}
			//查找右儿子
			if(rightNode!=null) {
				target=rightNode.frontSearch(i);
			}
		}
		return target;
	}
	
	//删除一个子树
	public void delete(int i) {
		ThreadedNode parent = this;
		//判断左儿子
		if(parent.leftNode!=null&&parent.leftNode.value==i) {
			parent.leftNode=null;
			return;
		}
		//判断右儿子
		if(parent.rightNode!=null&&parent.rightNode.value==i) {
			parent.rightNode=null;
			return;
		}
		
		//递归检查并删除左儿子
		parent=leftNode;
		if(parent!=null) {
			parent.delete(i);
		}
		
		//递归检查并删除右儿子
		parent=rightNode;
		if(parent!=null) {
			parent.delete(i);
		}
	}

}


package demo7;

public class ThreadedBinaryTree {

	ThreadedNode root;
	//用于临时存储前驱节点
	ThreadedNode pre=null;
	
	//遍历线索二叉树
	public void threadIterate() {
		//用于临时存储当前遍历节点
		ThreadedNode node = root;
		while(node!=null) {
			//循环找到最开始的节点
			while(node.leftType==0) {
				node=node.leftNode;
			}
			//打印当前节点的值
			System.out.println(node.value);
			//如果当前节点的右指针指向的是后继节点，可能后继节点还有后继节点、
			while(node.rightType==1) {
				node=node.rightNode;
				System.out.println(node.value);
			}
			//替换遍历的节点
			node=node.rightNode;
		}
	}
	
	//设置根节点
	public void setRoot(ThreadedNode root) {
		this.root = root;
	}
	
	//中序线索化二叉树
	public void threadNodes() {
		threadNodes(root);
	}
	
	public void threadNodes(ThreadedNode node) {
		//当前节点如果为null，直接返回
		if(node==null) {
			return;
		}
		//处理左子树
		threadNodes(node.leftNode);
		//处理前驱节点
		if(node.leftNode==null){
			//让当前节点的左指针指向前驱节点
			node.leftNode=pre;
			//改变当前节点左指针的类型
			node.leftType=1;
		}
		//处理前驱的右指针，如果前驱节点的右指针是null(没有指下右子树)
		if(pre!=null&&pre.rightNode==null) {
			//让前驱节点的右指针指向当前节点
			pre.rightNode=node;
			//改变前驱节点的右指针类型
			pre.rightType=1;
		}
		//每处理一个节点，当前节点是下一个节点的前驱节点
		pre=node;
		//处理右子树
		threadNodes(node.rightNode);
	}
	
	//获取根节点
	public ThreadedNode getRoot() {
		return root;
	}

	//前序遍历
	public void frontShow() {
		if(root!=null) {
			root.frontShow();
		}
	}

	//中序遍历
	public void midShow() {
		if(root!=null) {
			root.midShow();
		}
	}

	//后序遍历
	public void afterShow() {
		if(root!=null) {
			root.afterShow();
		}
	}

	//前序查找
	public ThreadedNode frontSearch(int i) {
		return root.frontSearch(i);
	}

	//删除子树
	public void delete(int i) {
		if(root.value==i) {
			root=null;
		}else {
			root.delete(i);
		}
	}
	
}


package demo7;

public class TestThreadedBinaryTree {

	public static void main(String[] args) {
		//创建一颗树
		ThreadedBinaryTree binTree = new ThreadedBinaryTree();
		//创建一个根节点
		ThreadedNode root = new ThreadedNode(1);
		//把根节点赋给树
		binTree.setRoot(root);
		//创建一个左节点
		ThreadedNode rootL = new ThreadedNode(2);
		//把新创建的节点设置为根节点的子节点
		root.setLeftNode(rootL);
		//创建一个右节点
		ThreadedNode rootR = new ThreadedNode(3);
		//把新创建的节点设置为根节点的子节点
		root.setRightNode(rootR);
		//为第二层的左节点创建两个子节点
		rootL.setLeftNode(new ThreadedNode(4));
		ThreadedNode fiveNode = new ThreadedNode(5);
		rootL.setRightNode(fiveNode);
		//为第二层的右节点创建两个子节点
		rootR.setLeftNode(new ThreadedNode(6));
		rootR.setRightNode(new ThreadedNode(7));
		//中序遍历树
		binTree.midShow();
		System.out.println("===============");
		//中前线索化二叉树
		binTree.threadNodes();
		binTree.threadIterate();
	}

}

线索二叉树的遍历

*Major*
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构期末试题11
08-03
1．在数据结构中，数据元素之间通常有下列四类基本结构：、、 2． 以下代码：y=0 3．用六叉链表表示 30 个结点的六叉树，则树中共有 __ __个空指针 4
C语言六叉树,递归创建二叉树c语言实现+详细解释
weixin_34502439的博客
05-19 175
该楼层疑似违规已被系统折叠隐藏此楼查看此楼voidCreatBiTree(BiTreeT){chara;scanf("%c",&a);if(a=='@')T=NULL;else{T=(BiTree)malloc(sizeof(BiNode));T->data=a;CreatBiTree(T->lchild);CreatBiTree(T->rchild);}}虽能编...
知识点总结（5）
weixin_43831728的博客
08-10 1321
1.以下哪个方法是类A的合法继承方法： class A { protected int method1(int a, int b) { return 0; } } 正确答案: A public int method1(int a, int b) {return 0; } private int method1(int a, int b) { return 0; } public short method1(int a, int b) { return 0; } static pr
j计算机二级基础知识,【日常干货】计算机二级基础知识（第四期）
weixin_33213911的博客
06-22 2348
原标题：【日常干货】计算机二级基础知识(第四期)考试即将到来小伙伴们加油鸭！(答案在题下方空白处，注意查收)1.设一棵树的度为3，其中没有度为2的结点，且叶子结点数为5。该树中度为3的结点数为A) 3B)1C) 2D)不可能有这样的树▼C【解析】设树的结点数为m，度为3的结点数为n，则度为1的结点数为m-n-5, 根据树中的结点数=树中所有结点的度之和+1，得3×n+1×(m-n-5)+5×0+1...
数据结构(六)树
Rookie_cong的博客
09-23 345
未完待续树的概念： 子树 根结点 内部结点 叶结点或终端结点 深度或高度：根为第一层，根的孩子为第二层，依次类推，树中结点最大的层数就称为深度或高度。 在树中，如果任意一个结点的子树，从左到右都是有次序的，那么这棵树被称为有序树，反之则为无序树。 森林：由多棵不相交的树的集合。树的存储结构： 双亲表示法： 双亲域：每个结点设置一个指向双亲位置的单元。 长子域：每个结点设置一个指向第一
六 树和二叉树
xlbety的博客
10-24 382
6.1 树的定义 树（Tree）是n(n >= 0)个节点的有限集。 6.2 树的基本术语 结点：
实验六 二叉树操作.docx
11-12
本实验"实验六 二叉树操作.docx"显然着重于探讨如何操作和遍历二叉树，特别是通过层序遍历的方式。在这个过程中，我们将深入理解二叉树的性质、层序遍历的概念，以及如何实现这一遍历方法。 首先，二叉树是由节点...
实验六 二叉树操作.pdf
11-12
二叉树是一种数据结构，它由结点（或称为节点）构成，每个结点最多有两个子结点，分别称为左子结点和右子结点。在这个实验中，我们将深入理解二叉树的性质，并学习如何使用数组来存储和操作二叉树。 实验目标是掌握...
实验六 二叉树及其应用.docx
11-12
实验六的目的是让学生熟悉二叉树的存储结构和应用，特别是在解决实际问题中的作用，比如构建和操作算术表达式。二叉树是一种重要的非线性数据结构，它由节点构成，每个节点最多有两个子节点，通常分为左子节点和右子...
实验六 二叉树及其应用.pdf
最新发布
11-12
二叉树是一种重要的数据结构，它在计算机科学中有着广泛的应用，特别是在算法和数据结构领域。本实验旨在帮助学生深入理解二叉树的特性和操作，以及如何利用它们解决实际问题，例如构建一个十进制四则运算的计算器。...
实验六 二叉树操作.cpp
11-23
实验六 二叉树操作.cpp
数据结构实验六 树（二叉链表，统计结点总数及叶子结点数）
沧浪之水
02-06 3915
一、 实验目的 1． 熟悉二叉树的链式存储结构 2． 掌握二叉树的建立、深度优先递归遍历等算法 3． 能够利用遍历算法实现一些应用 二、 实验内容 1． 已知二叉树采用二叉链表存储结构，如果左、右子树非空，且左子树根结点大于右子树根结点，则交换根结点的左、右子树。即按要求交换二叉树及子树的左、右子树。 2． 采用二叉链表结构存储一棵二叉树，编写一个算法统计该二叉树中结点总
数据结构 学习总结6 树和二叉树
weixin_44801852的博客
06-19 697
目录标题树的基本概念二叉树的性质二叉树的存储结构遍历二叉树和线索二叉树线索二叉树（Threaded Binary Tree）树和森林Huffman树及其应用 特点：非线性结构，一个直接前驱，但可能有多个直接后继（1：n） 树在计算机领域中广泛应用，例如： 在编译程序中，用树来表示源程序的语法结构； 在数据库系统中，可用树来组织信息； 在分析算法的行为时，可用树来描述其执行过程等等。 树的基本概念 由0个或多个(n≥0)结点组成的有限集合T，有且仅有一个结点称为根（root），当n>1时，其余的结点分为
已知完全二叉树有30个节点，则整个二叉树有 1 个度为1的节点。
05-12 6903
已知完全二叉树有30个节点，则整个二叉树有_1--个度为1的节点。 解答： 完全二叉树：除了最外层，其余层上的节点数目都达到最大值，而第h层上的节点集中存放在左侧树中。     n0是度为0的节点总数(即叶子节点数)，n1是度为1的节点总数，n2是度为2的节点总数，由二叉树的性质可知：     n0=n2+1，则完全二叉树的节点总数n为：    n=n0+n1+n2，由于完全二叉树中
数据结构学习笔记（5.树与二叉树 6.图）
super_song的博客
05-22 827
文章目录第五章 树与二叉树树树的常考性质 第五章 树与二叉树 树 树的基本概念 空树，非空树 非空树特性 树的基本概念 数学描述 子树，子树之间互不相交 树是一种递归定义的结构，任何一个树都可以看做是由根节点和若干个不相交的子树所组成的 树形逻辑结构的应用 结点之间的关系描述 祖先结点：从一个节点出发一直往上走，直到根节点，所遇到的所有节点都是祖先结点 子孙结点：从一个节点出发，下面所有长出的节点都是他的子孙结点 双亲结点：一个结点的直接前驱，就是双亲结点，也叫父结点 孩子结点：一个结点的
大话数据结构第六章笔记 （树）
wsfhdhjs的博客
05-06 439
6.2树的定义： 1.树是n个结点的有限集，n=0时称为空树 2.有且仅有一个特定的根 3.子树的个数没有限制，但他们一定是不相交，如下图，就不是子树 4.结点拥有的子树数称为结点的度。度为0的结点称为叶节点；度不为0的结点称为分支结点。除根节点之外，分支节点也称内部结点；树的度是树内各结点的度的最大值，如下图 6.3结点间的关系： 1.结点的祖先是从根到该结点所经分支上的所有结点 对于H而言...
八叉树和十六叉树结构
Chinamming的专栏
11-24 869
(1)三维和四维数据结构的提出。前面介绍的数据结构都是二维的，然而在有些信息系统中，需要有真三维的空间数据结构。例如矿山开采中的地下资源埋藏和采矿巷道的空间分布，如果用二维的坐标体系就根本无法很好表达。此外，矿山空间目标往往随时间不断变化着，这就提出了空间和时间信息系统的问题。 在时间信息系统中不考虑时间，是把时间看作不变的常数，即为当前的时间。而在时间和空间信息系统中，则把时间看作有过...
图解数据结构（6）——树及树的遍历
weixin_33939843的博客
06-27 196
八、树（Tree）树，顾名思义，长得像一棵树，不过通常我们画成一棵倒过来的树，根在上，叶在下。不说那么多了，图一看就懂： 当然了，引入了树之后，就不得不引入树的一些概念，这些概念我照样尽量用图，谁会记那么多文字？ 树这种结构还可以表示成下面这种方式，可见树用来描述包含关系是很不错的，但这种包含关系不得出现交叉重叠区域，否则就不能用树描述了，看图： 面试的时候我们经常被考到的是一种叫“二叉树”...
递归和迭代的区别
热门推荐
Tonynono的专栏
03-02 12万+
递归的基本概念:程序调用自身的编程技巧称为递归,是函数自己调用自己.一个函数在其定义中直接或间接调用自身的一种方法,它通常把一个大型的复杂的问题转化为一个与原问题相似的规模较小的问题来解决,可以极大的减少代码量.递归的能力在于用有限的语句来定义对象的无限集合.使用递归要注意的有两点:1)递归就是在过程或函数里面调用自身;2)在使用递归时,必须有一个明确的递归结束条件,称为递归出口.
数据结构：第六章 树与二叉树详解
"第六章 树和二叉树章节涵盖了关于树形数据结构的基础知识，适合初学者，有助于后续数据结构的学习。主要内容包括树的类型定义、基本术语、二叉树的定义、存储结构、遍历方法、线索二叉树、树和森林的表示以及遍历，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值