数据结构学习第十六课(有序二叉树)

最新推荐文章于 2024-08-21 14:24:26 发布
最新推荐文章于 2024-08-21 14:24:26 发布
阅读量624 收藏
点赞数
分类专栏： 数据结构学习笔记 文章标签： 数据结构 算法 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kdnnnd/article/details/118731056
版权

有序二叉树

1,头文件
#pragma once
template<typename T>
class MyTree
{
private:
	struct Node
	{
		T data;//数据
		Node* pLeft;//指向左孩子
		Node* pRight;//指向右孩子
	};
	Node* pRoot;//指向树根
public:
	MyTree();
	~MyTree();

	void insertNode(const T& data);//插入一个节点到树中
	void travel();//遍历
	//已知顺序推导树结构
	//已知 先序和中序 能推导出 树的形状
	//已知 中序和后序 能推导出 树的形状
	//已知 先序和后序 不能推导出 树的形状
	void deleteNode(const T& data);//删除
	/*
	1,找到要删除的节点,如果找不到直接结束;
	2 找到了,判断要删除的节点是否为根结点
	 2.1是根结点
	    2.1.1 有右孩子
		      让根结点的左孩子成为 根结点的右孩子的最左孩子;
			  删掉根结点
			  让根结点的右孩子成为根结点
        2.1.2 没有右孩子
		      删掉根结点
			  让根结点的左孩子成为根结点
      2.2不是根结点
	    2.2.1 找到要删除的节点(pDelete)的父结点(pDelParent)
		2.2.2 要删除的节点是其父结点的左孩子
		 2.2.2.1 pDelete有右孩子
		         让PDelete的左孩子成为PDelete的右孩子的最左孩子
				 删除PDelete
				 pDelete的右孩子成为PDelParent的左孩子
		 2.2.2.1 pDelete没有右孩子
				 删除PDelete
				 pDelete的左孩子成为PDelParent的左孩子
		2.2.3  要删除的节点是其父结点的右孩子
		 2.2.3.1 pDelete有右孩子
		         让PDelete的左孩子成为PDelete的右孩子的最左孩子
				 删除PDelete
				 pDelete的右孩子成为PDelParent的右孩子
		 2.2.3.1 pDelete没有右孩子
				 删除PDelete
				 pDelete的左孩子成为PDelParent的右孩子
	
	*/
private:
	void _preTravel(Node* pRoot);
	void _midTravel(Node* pRoot);
	void _lstTravel(Node* pRoot);
	Node* _createNode(const T& data)
	{
		Node* pNew = new Node;
		pNew->data = data;
		pNew->pLeft = pNew->pRight = NULL;
		return pNew;
	}

	//插入一个节点到树中
	void _insertNode(Node** root, const T& data);
	void _insertNode(Node*& root, const T& data);
	//从树中找某个节点,找到返回节点地址,否则返回NULL
	Node* _findNode(Node* root, const T& data);
};

template<typename T>
inline MyTree<T>::MyTree()
{
	pRoot = NULL;
}

template<typename T>
inline MyTree<T>::~MyTree()
{

}

template<typename T>
inline void MyTree<T>::insertNode(const T& data)
{
	//_insertNode(&pRoot, data);
	_insertNode(pRoot,data);
}

template<typename T>
inline void MyTree<T>::travel()
{
	//先序 : 根 左 右
	printf("先序:");
	_preTravel(pRoot);
	//中序 : 左 根 右 
	printf("\n");
	printf("中序:");
	_midTravel(pRoot);
	//后序 : 左 右 根
	printf("\n");
	printf("后序:");
	_lstTravel(pRoot);
}

template<typename T>
inline void MyTree<T>::deleteNode(const T& data)
{
	//1 找到删除的节点
	Node* pDelete = _findNode(pRoot, data);
	if (pDelete)
	{
		printf("找到了%d\n", pDelete->data);
	}
	else
	{
		printf("没找到\n");
	}
	Node* pTemp = NULL;
	Node* pBuff = NULL;
	//2 判断是否为根结点
	if (pRoot == pDelete)//2.1 是根结点
	{
		if (pRoot->pRight)//2.1.1 有右孩子
		{
			//找到根结点的右孩子的最左孩子;
			pBuff=pTemp = pRoot->pRight;
			while (pTemp->pLeft)
			{
				pTemp = pTemp->pLeft;
			}
			// 让根结点的左孩子成为 根结点的右孩子的最左孩子;
			pTemp->pLeft = pRoot->pLeft;
			//删掉根结点
			delete pRoot;
			//让根结点的右孩子成为根结点
			pRoot = pBuff;
		}
		else//2.1.2 没有右孩子
		{
			pBuff = pRoot->pLeft;
			//删掉根结点
			delete pRoot;
			//让根结点的左孩子成为根结点
			pRoot = pBuff;
		}
		return;
	}
	// 2.2不是根结点
	//2.2.1 找到要删除的节点(pDelete)的父结点(pDelParent)
	Node* pDelParent = NULL;
	pDelete = pRoot;
	while (pDelete)
	{
		if (data == pDelete->data)
		{
			break;
		}
		pDelParent = pDelete;
		if (data > pDelete->data)
		{
			pDelete = pDelete->pRight;
		}
		else
		{
			pDelete = pDelete->pLeft;
		}
	}
	printf("要删除的:%d ,父结点: %d\n", pDelete->data, pDelParent->data);

	if (pDelete == pDelParent->pLeft)//2.2.2 要删除的节点是其父结点的左孩子
	{
		if (pDelete->pRight)//2.2.2.1 pDelete有右孩子
		{
			//找到PDelete的右孩子的最左孩子
			pBuff= pTemp = pDelete->pRight;
			while (pTemp->pLeft)
			{
				pTemp = pTemp->pLeft;
			}
			//让PDelete的左孩子成为PDelete的右孩子的最左孩子
			pTemp->pLeft = pDelete->pLeft;
			//删除PDelete
			delete pDelete;
			//pDelete的右孩子成为PDelParent的左孩子
			pDelParent->pLeft = pBuff;
		}
		else//2.2.2.2 pDelete没有右孩子
		{
			pBuff = pDelete->pLeft;
			//删除PDelete
			delete pDelete;
			//pDelete的左孩子成为PDelParent的左孩子
			pDelParent->pLeft = pBuff;
		}
	}
	else//2.2.3  要删除的节点是其父结点的右孩子
	{
		if (pDelete->pRight)//	2.2.3.1 pDelete有右孩子
		{
			//找到PDelete的右孩子的最左孩子
			pBuff = pTemp = pDelete->pRight;
			while (pTemp->pLeft)
			{
				pTemp = pTemp->pLeft;
			}
			//让PDelete的左孩子成为PDelete的右孩子的最左孩子
			pTemp->pLeft = pDelete->pLeft;
			//删除PDelete
			delete pDelete;
			//pDelete的右孩子成为PDelParent的右孩子
			pDelParent->pRight = pBuff;
		}
		else//	2.2.3.1 pDelete没有右孩子
		{
			pBuff = pDelete->pLeft;
			//删除PDelete
			delete pDelete;
			//	pDelete的左孩子成为PDelParent的右孩子
			pDelParent->pRight = pBuff;
		}	
	}
	
}
template<typename T>
inline void MyTree<T>::_preTravel(Node* pRoot)
{
	if (NULL == pRoot)
	{
		return;
	}
	printf("%d ", pRoot->data);//根
	_preTravel(pRoot->pLeft);//左
	_preTravel(pRoot->pRight);//右
}

template<typename T>
inline void MyTree<T>::_midTravel(Node* pRoot)
{
	if (NULL == pRoot)
	{
		return;
	}
	_midTravel(pRoot->pLeft);//左
	printf("%d ", pRoot->data);//根
	_midTravel(pRoot->pRight);//右
}


template<typename T>
inline void MyTree<T>::_lstTravel(Node* pRoot)
{
	if (NULL == pRoot)
	{
		return;
	}
	_lstTravel(pRoot->pLeft);//左
	_lstTravel(pRoot->pRight);//右
	printf("%d ", pRoot->data);//根
}

template<typename T>
inline void MyTree<T>::_insertNode(Node** root, const T& data)
{
	if (NULL == *root)
	{
		*root = _createNode(data);
		return;
	}
	if ((*root)->data < data)//放右边
	{
		_insertNode(&(*root)->pRight, data);
	}
	else//放左边
	{
		_insertNode(&(*root)->pLeft, data);
	}
}

template<typename T>
inline void MyTree<T>::_insertNode(Node*& root, const T& data)
{
	if (NULL == root)
	{
		root = _createNode(data);
		return;
	}
	if ((root)->data < data)//放右边
	{
		_insertNode(root->pRight, data);
	}
	else//放左边
	{
		_insertNode(root->pLeft, data);
	}
}

template<typename T>
typename MyTree<T>:: Node* MyTree<T>::_findNode(Node* root, const T& data)
{
	Node* pTemp = root;
	while (pTemp)
	{
		if (data == pTemp->data)
		{
			return pTemp;
		}
		if (data > pTemp->data)
		{
			pTemp = pTemp->pRight;
		}
		else
		{
			pTemp = pTemp->pLeft;
		}
	}
	return NULL;
}
2,源文件
/*
1, 有序二叉树
升序: 左<根<右
降序: 左>根>右
2,做一棵有序二叉树
2.1 有序二叉树类
2.2. 插入
2.3 遍历
2.4 删除
*/
#include<stdio.h>
#include"MyTree.h"
int main()
{
	MyTree<int> tree;
	tree.insertNode(3);
	tree.insertNode(8);
	tree.insertNode(6);
	tree.insertNode(2);
	tree.insertNode(1);
	tree.insertNode(7);
	tree.insertNode(9);
	tree.insertNode(66);
	tree.insertNode(55);
	tree.insertNode(34);
	tree.travel();
	int n;
	while (1)
	{
		printf("输入删除的节点:");
		scanf("%d", &n);
		tree.deleteNode(n);
		tree.travel();
	}

	while (1);
	return 0;
}
kdnnnd
关注
专栏目录
Java有序二叉树
Author1thy的博客
08-24 252
代码： package com.wangyq.datastructrue.tree; public class OrderedTree { private static OrderedTreeNode rootNode; public static void main(String[] args) { int[] ints = {65, 64, 561, 213, 5479, 87465, 13, 9, 7984, 31, 6874, 51, 321, 84, 651,
有序二叉树
ajdhfla的博客
11-21 182
public class TreeNode { public int value; public TreeNode left; public TreeNode right; public String toString() { return"[节点值=" + value +"，左=" + left + "，右=" + right +"]"; } } public class Shu { public static void main(String[] args) { int[] arr
数据结构——二叉排序树（有序二叉树）
最新发布
helloworld1932的博客
08-21 223
二叉排序树的介绍以及相关操作：构建、销毁、遍历、高度、密度、插入、删除、查询、求左、求右、求根
有序二叉树，平衡二叉树，二三四树，红黑树
m0_61983575的博客
03-31 955
有序二叉树： 平衡二叉树具有以下特点： 1）它是一颗空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两颗子树都是一颗平衡二叉树。 2）平衡因子： 左子树的高度 - 右子树的高度 我们将平衡因子的绝对值小于1的的有序二叉树称为平衡二叉树 旋转：LL,RR LL RR LR RL 造成不平衡的节点最后插入 红黑树 红黑树：介于有序二叉树和平衡二叉树之间的树，最优二叉树 二三四树 红黑树 红黑树中的节点不是红色就是黑色 红黑树中根节点一定是黑
算法与数据结构 第五章 树与二叉树（详解）
m0_62205773的博客
05-06 3974
目录 一、判断题 二、选择题 在开始之前，先为大家推荐两篇介绍该章两个主要算法的的文章，供大家参考。 Huffman树：Huffman树 树，二叉树，森林的转化：树，二叉树，森林的转化 一、判断题 1、二叉树可以用二叉链表存储，树无法用二叉链表存储。F 解析：二叉树与树都可以用二叉链表作为存储结构，二者的关系是一棵树可以惟一对应一棵二叉树。 2、某二叉树的后序和中序遍历序列正好一样，则该二叉树中的任何结点一定都无左孩子。F 解析：某二叉树的后序和中序遍历序列正好一样，则该二叉树中的任何.
数据结构学习笔记（5.树与二叉树 6.图）
super_song的博客
05-22 970
文章目录第五章 树与二叉树树树的常考性质 第五章 树与二叉树 树 树的基本概念 空树，非空树 非空树特性 树的基本概念 数学描述 子树，子树之间互不相交 树是一种递归定义的结构，任何一个树都可以看做是由根节点和若干个不相交的子树所组成的 树形逻辑结构的应用 结点之间的关系描述 祖先结点：从一个节点出发一直往上走，直到根节点，所遇到的所有节点都是祖先结点 子孙结点：从一个节点出发，下面所有长出的节点都是他的子孙结点 双亲结点：一个结点的直接前驱，就是双亲结点，也叫父结点 孩子结点：一个结点的
江南大学《数据结构与算法A》2022-2023学年第一学期期末试卷A(带答案)
08-27
以下是对江南大学《数据结构与算法A》2022-2023学年第一学期期末试卷A中部分内容的详细解释： 1. **排序算法**： - **稳定排序**：指的是相等的元素在排序后的相对位置不会改变。题目中提到的四种排序算法中，只有...
数据结构习题解析：树与二叉树
"这是一份关于自考2331数据结构的习题答案，包含第六章至第十章的内容，涉及树、图、排序、查找和文件等主题。习题解答详尽，适合复习和备考使用。" 在数据结构的学习中，树是一种重要的数据组织形式。第六章讲述了...
数据结构知识点总结09-(第五章.树与二叉树)-二叉树的相关概念、性质、存储结构、二叉树的遍历、线索二叉树
随风浪仔的专栏
02-28 317
数据结构知识点总结-(第五章.树与二叉树)-二叉树的相关概念、性质、存储结构、二叉树的遍历、线索二叉树。二叉树的一种特殊的树形结构，其特点是每个结点至多只有两颗子树，二叉树中不存在度大于2的结点，并且二叉树的子树有左右之分，其次序不能交换颠倒（即二叉树是有序树）。二叉树的这一特点，使得他实现起来简单，应用面更广。二叉树也有递归的形式定义，二叉树是 n ( n ≥ 0 )个结点的有限集合，为空树时 n = 0。由一个根结点和连个互不相交的根的左子树和右子树组成，其中左、右子树均是二叉树。
有序平衡二叉树(AVL树)
07-23
一棵AVL树或者是空树，或者是具有下列性质的二叉搜索树：它的左子树和右子树都是AVL树，且左子树和右子树的高度之差的绝对值不超过1。
根据输入一组数据，建立有序二叉树
12-30
输入若干数据，以任意字母结束，以此数据建立有序二叉树，并先序遍历输出。
Day7：有序二叉树（二叉搜索树）
zjjaibc的博客
07-24 1832
二叉搜索树基本知识点
二 叉 树（是有序树）
zxf347085420的博客
02-21 1211
如果把一棵非空的树的根节点删除，则该树就变成了一片森林，森林中的树由原来根节点的各棵子树构成 [5]。2、完全二叉树：深度为k，有n个节点的二叉树当且仅当其每一个节点都与深度为k的满二叉树中编号从1到n的节点一一对应时，称为完全二叉树 [4]。⑥节点的层次：从根节点开始，假设根节点为第1层，根节点的子节点为第2层，依此类推，如果某一个节点位于第L层，则其子节点位于第L+1层 [5]。1、满二叉树：如果一棵二叉树只有度为0的节点和度为2的节点，并且度为0的节点在同一层上，则这棵二叉树为满二叉树 [4]。
有序二叉树的实现
romancegirls的专栏
04-24 1459
头文件“bt.h”/* 有序二叉树 */ #ifndef _BT_H #define _BT_H #include /* 节点 */ typedef struct BsTreeNode { int data; /* 数据 */ struct BsTreeNode* left; /* 左子树 */ struct BsTreeNode* right; /* 右
数据映射–平衡二叉有序树
weixin_33736649的博客
08-26 175
上次我们提到了使用有序的数组来进行二分查找，从而提高映射查询的效率，使时间复杂度从O(n)降低到O(log2N).本周让我来介绍一下二叉树。一谈到二叉树，相信很多人一定会有一个疑问：这玩意儿有什么用？（当然这么多人里面肯定包括大学时候的我--）其实，我个人觉得这并不怪我们，是教科书写的有点问题，开始的时候没有给到大家明确的学习意义，开始就去讲如何遍历，如何从树变森林，如何做树...
数据结构-有序二叉树的创建
m0_52012606的博客
01-02 648
构建有序二叉树有两种构建方法： 1、有序插入 （大于根节点放右边 小于根节点放左边） 2、使用递归 1.有序插入 新建TreeNode节点 public class TreeNode { public TreeNode lc;//左子树 public TreeNode rc;//右子树 public Integer value;//插入的值 public TreeNode(Integer value) { this.value = value; } } 新建BinaryT
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值