算法学习-二叉查找树

最新推荐文章于 2023-05-17 09:01:52 发布
最新推荐文章于 2023-05-17 09:01:52 发布
阅读量526 收藏
点赞数
分类专栏： 算法学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HelloNiGeSB/article/details/53260901
版权

  1. typedef struct tagSTreeNode  
  2. {  
  3.     int value;  
  4.     tagSTreeNode* pLeft;  
  5.     tagSTreeNode* pRight;  
  6.   
  7.     tagSTreeNode(int v) : value(v), pLeft(NULL), pRight(NULL){}  
  8. }STreeNode;  
  9.   
  10. typedef void (*VISIT)(int value);  // 定义一个  
  11.   
  12. class CBinaryTree  
  13. {  
  14. private:  
  15.     STreeNode* m_pRoot;  
  16.   
  17. private:  
  18.     void Destory(STreeNode* pRoot);  
  19.     bool _Insert(STreeNode*& pRoot, int value);                  // 递归  
  20.     bool _Insert2(int value);                                    // 非递归  
  21.     void _PreOrder(STreeNode* pRoot, VISIT Visit) const;         // 递归  
  22.     void _PreOrder2(VISIT Visit) const;                          // 非递归  
  23.     void _InOrder(STreeNode* pRoot, VISIT Visit) const;          // 递归  
  24.     void _InOrder2(VISIT Visit) const;                           // 非递归  
  25.     void _InOrder3(VISIT Visit) const;                           // 非递归  
  26.     void _PostOrder(STreeNode* pParent, VISIT Visit) const;      // 递归  
  27.     void _PostOrder2(VISIT Visit) const;                         // 非递归  
  28.     void DeleteChildless(STreeNode* pParent, STreeNode* pNode);  // pNode无子  
  29.     void DeleteSingleSon(STreeNode* pParent, STreeNode* pNode);  // pNode是pParent唯一子节点  
  30. public:  
  31.     CBinaryTree();  
  32.     ~CBinaryTree();  
  33.     bool Insert(int value);  
  34.     bool Delete(int value);  
  35.     STreeNode* Find(int value) const;  
  36.     void PreOrder(VISIT Visit) const;  
  37.     void InOrder(VISIT Visit) const;  
  38.     void PostOrder(VISIT Visit) const;  
  39. };  


二叉查找树（二叉搜索树）是满足一下条件的二叉树：

左子树上的所有结点值均小于根结点值，

右子树上的所有结点值均不小于根结点值，

左右子树也满足上述两个条件。

结点的查找

STreeNode* CBinaryTree::Find(int value) const
{
	if (!m_pRoot)
	{
		return NULL;
	}

	STreeNode* pNode = m_pRoot;
	while (pNode)
	{
		if (value < pNode->value)
		{
			pNode = pNode->pLeft;
		}
		else if (value > pNode->value)
		{
			pNode = pNode->pRight;
		}
		else
			return pNode;
	}
	return NULL;
}
结点的插入的递归和非递归版本，可以通过插入函数来创建查找二叉树 

bool CBinaryTree::Insert(int value)
{
	return _Insert(m_pRoot, value);
}

bool CBinaryTree::_Insert(STreeNode*& pRoot, int value)
{
	if (!m_pRoot)
	{
		pRoot = new STreeNode(value);
		return true;
	}

	if (value < pRoot->value)
		return _Insert(pRoot->pLeft, value);
	if (value > pRoot->value)
		return _Insert(pRoot->pRight, value);
	return false;
}

bool CBinaryTree::_Insert2(int value)
{
	if (m_pRoot)
	{
		m_pRoot = new STreeNode(value);
		return true;
	}
	STreeNode* pNode = m_pRoot;
	STreeNode* pCur = m_pRoot;
	while (pNode)
	{
		pCur = pNode;
		if (value < pNode->value)
			pNode = pNode->pLeft;
		else if (value > pNode->value)
			pNode = pNode->pRight;
		else
			return false;
	}
	if (value < pCur->value)
		pCur->pLeft = new STreeNode(value);
	else if (value > pCur->value)
		pCur->pRight = new STreeNode(value);
	return true;
}

二叉查找树的删除：

记待删除的结点为p，分三种情况进行处理

  1. p为叶子结点
  2. p为单支结点
  3. p的左子树和右子树均不空
p为叶子结点，直接删除该结点，在修改p的父节点的指针


若p为单支结点（即只有左子树或右子树），则将p的子树与p的父亲结点相连，删除p即可


若p的左子树和右子树均不空，则找到p的直接后继d（p的右孩子的最左子孙），因为d一定没有左子树，所以使用删除单支节点的方法删除d，并让d的父亲结点dp成为右子树的父亲节点；同时用d的值代替p的值；（或者可以找到p的直接前驱x（p的左孩子的最右子孙），x一定没有右子树，所以可以删除x，并让x的父节点成为x的左子树的父亲结点。）


// 删除叶子结点 辅助函数
void CBinaryTree::DeleteChildless(STreeNode* pParent, STreeNode* pNode)
{
	if (pNode == m_pRoot)
		m_pRoot = NULL;
	else if (pParent->pLeft == pNode)
		pParent->pLeft = NULL;
	else
		pParent->pRight = NULL;
	delete pNode;
}

// 删除单支结点 辅助函数
void CBinaryTree::DeleteSingleSon(STreeNode* pParent, STreeNode* pNode)
{
	STreeNode* pGrandSon = pNode->pLeft ? pNode->pLeft : pNode->pRight;
	if (pNode == m_pRoot)
		m_pRoot = pGrandSon;
	else if (pParent->pLeft == pNode)
		pParent->pLeft = pGrandSon;
	else
		pParent->pRight = pGrandSon;
	delete pNode;
}

// 删除结点
bool CBinaryTree::Delete(int value)
{
	if (!m_pRoot)
	{
		return false;
	}
	STreeNode* pNode = m_pRoot;
	STreeNode* pParent = NULL;
	while (pNode)
	{
		if (value < pNode->value)
		{
			pParent = pNode;
			pNode = pNode->pLeft;
		}
		else if (value > pNode->value)
		{
			pParent = pNode;
			pNode = pNode->pRight;
		}
		else  // 找到待删除值
			break;
	}
	if (!pNode) // 没有找到
	{
		return false;
	}
	if (!pParent)
	{
		pParent = m_pRoot;
	}
	if (!pNode->pLeft && !pNode->pRight)
	{
		DeleteChildless(pParent, pNode);
	}
	else if (!pNode->pLeft || !pNode->pRight)
	{
		DeleteSingleSon(pParent, pNode);
	}
	else
	{
		STreeNode* pCur = pNode; // 暂存待删除结点
		pParent = pNode;
		pNode = pNode->pLeft;
		while (pNode->pRight)
		{
			pParent = pNode;
			pNode = pNode->pRight;
		}
		pCur->value = pNode->value;
		if (!pNode->pLeft)
		{
			DeleteChildless(pParent, pNode);
		}
		else
		{
			DeleteSingleSon(pParent, pNode);
		}
	}
	return true;
}

二叉树的遍历：

前序遍历

void CBinaryTree::PreOrder(VISIT Visit) const
{
	_PreOrder(m_pRoot, Visit);
}

void CBinaryTree::_PreOrder(STreeNode* pRoot, VISIT Visit) const
{
	if (pRoot)
	{
		Visit(pRoot->value);
		_PreOrder(pRoot->pLeft, Visit);
		_PreOrder(pRoot->pRight, Visit);
	}
}

void CBinaryTree::_PostOrder2(VISIT Visit) const
{
	if (!m_pRoot)
	{
		return;
	}
	std::stack<STreeNode*> s;
	s.push(m_pRoot);
	STreeNode* pCur;
	while (!s.empty())
	{
		pCur = s.top();
		s.pop();
		Visit(pCur->value);
		if (pCur->pRight)
			s.push(pCur->pRight);
		if (pCur->pLeft)
			s.push(pCur->pLeft);
	}
}

中序遍历：二叉树查找树的中序遍历，即为数据的升序过程 

void CBinaryTree::InOrder(VISIT Visit) const
{
	_InOrder(m_pRoot, Visit);
	//_InOrder2(Visit);
}

void CBinaryTree::_InOrder(STreeNode* pRoot, VISIT Visit) const
{
	if (pRoot)
	{
		_InOrder(pRoot->pLeft, Visit);
		Visit(pRoot->value);
		_InOrder(pRoot->pRight, Visit);
	}
}

void CBinaryTree::_InOrder2(VISIT Visit) const
{
	std::stack<STreeNode*> s;
	STreeNode* pCur = m_pRoot;
	while (pCur || !s.empty())
	{
		while(pCur)
		{
			s.push(pCur);
			pCur = pCur->pLeft;
		}
		if (!s.empty())
		{
			pCur = s.top();
			s.pop();
			Visit(pCur->value);
			pCur = pCur->pRight;
		}
	}
}

void CBinaryTree::_InOrder3(VISIT Visit) const
{
	if (!m_pRoot)
	{
		return;
	}

	std::stack<std::pair<STreeNode*, int>> s;
	s.push(std::make_pair(m_pRoot, 0));
	int times;
	STreeNode* pCur;
	while (!s.empty())
	{
		pCur = s.top().first;
		times = s.top().second;
		s.pop();
		if (times == 0) // 第一次压栈
		{
			if (pCur->pRight)
				s.push(std::make_pair(pCur->pRight, 0));
			s.push(std::make_pair(pCur, 1)); // 第二次压栈
			if (pCur->pLeft)
				s.push(std::make_pair(pCur->pLeft, 0));
		}
		else
		{
			Visit(pCur->value);
		}
	}
}

后续遍历

void CBinaryTree::PostOrder(VISIT Visit) const
{
	_PostOrder(m_pRoot, Visit);
	//_PostOrder2(Visit);
}

void CBinaryTree::_PostOrder(STreeNode* pParent, VISIT Visit) const
{
	if (pParent)
	{
		_PostOrder(pParent->pLeft, Visit);
		_PostOrder(pParent->pRight, Visit);
		Visit(pParent->value);
	}
}

void CBinaryTree::_PostOrder2(VISIT Visit) const
{
	if (!m_pRoot)
		return;
	std::stack<std::pair<STreeNode*, int>> s;
	s.push(std::make_pair(m_pRoot, 0));
	int times;
	STreeNode* pCur;
	while (!s.empty())
	{
		pCur = s.top().first;
		times = s.top().second;
		s.pop();
		if (times == 0)
		{
			s.push(std::make_pair(pCur, 1));
			if (pCur->pRight)
			{
				s.push(std::make_pair(pCur->pRight, 0));
			}
			if (pCur->pLeft)
			{
				s.push(std::make_pair(pCur->pLeft, 0));
			}
		}
		else
		{
			Visit(pCur->value);
		}
	}
}
根据前序中序，计算后序

如：已知某二叉树的遍历结果如下，求它的后序遍历序列

前序遍历：GDAFEMHZ

中序遍历：ADEFGHMZ

两个步骤：

根据前序中序，构造二叉树

后序遍历二叉树

由前序知道G为二叉树的根结点，根据中序可以得到ADEF为二叉树的左子树，HMZ为二叉树的右子树，下面的依次递归可得到

代码如下

void InPre2Post(const char* pInOrder, const char* pPreOrder, int nLength, char* pPostOrder, int& nIndex)
{
	if (nLength <= 0)
		return;
	if (nLength == 1)
	{
		pPostOrder[nIndex] = *pPreOrder;
		nIndex++;
		return;
	}
	char root = *pPreOrder;
	int nRoot = 0;
	for (; nRoot < nLength; nRoot++)
	{
		if (pInOrder[nRoot] == root)
			break;
	}
	InPre2Post(pInOrder, pPreOrder + 1, nRoot, pPostOrder, nIndex);
	InPre2Post(pInOrder + nRoot + 1, pPreOrder + nRoot + 1, nLength - (nRoot + 1), pPostOrder, nIndex);
	pPostOrder[nIndex] = root;
	nIndex++;
}

int _tmain(int argc, _TCHAR* argv[])
{
	char pPreOrder[] = "GDAFEMHZ";
	char pInOrder[] = "ADEFGHMZ";
	int size = sizeof(pInOrder) / sizeof(char);
	char* pPostOrder = new char[size];
	int nIndex = 0;
	InPre2Post(pInOrder, pPreOrder, size - 1, pPostOrder, nIndex);
	pPostOrder[size - 1] = 0;
	std::cout<<pPostOrder<<std::endl;
	delete[] pPostOrder;
	system("pause");
	return 0;
}
还可以通过中序后序求前序，代码如下 
void InPost2Pre(const char* pInOrder, const char* pPostOrder, int nLength, char* pPreOrder, int& nIndex)
{
	if (nLength <=0)
		return;
	if (nLength == 1)
	{
		pPreOrder[nIndex] = *pPostOrder;
		nIndex++;
		return;
	}
	char root = pPostOrder[nLength - 1];
	pPreOrder[nIndex] = root;
	nIndex++;
	int nRoot = 0;
	for (; nRoot < nLength; nRoot++)
	{
		if (pInOrder[nRoot] == root)
			break;
	}
	InPost2Pre(pInOrder, pPostOrder, nRoot, pPreOrder, nIndex);
	InPost2Pre(pInOrder + nRoot + 1, pPostOrder + nRoot, nLength - (nRoot + 1), pPreOrder, nIndex);
}

int _tmain(int argc, _TCHAR* argv[])
{
	char pPostOrder[] = "AEFDHZMG";
	char pInOrder[] = "ADEFGHMZ";
	int size = sizeof(pInOrder) / sizeof(char);
	char* pPreOrder = new char[size];
	int nIndex = 0;
	InPre2Post(pInOrder, pPostOrder, size - 1, pPreOrder, nIndex);
	pPreOrder[size - 1] = 0;
	std::cout<<pPreOrder<<std::endl;
	delete[] pPreOrder;
	system("pause");
	return 0;
}

注：必须知道中序才可求别的，只知道前序后序是无法求出中序的，但是特殊情况是可以


思考：

给定整数数组，判断该数组有无可能是一颗二叉查找树后序遍历的结果。假定数组中没有重复元素，编程如何实现

以下序列中不可能是一颗二叉查找树后序遍历结果的是哪个？答案：B

A、1,2,3,4,5

B、3,5,1,4,2

C、1,2,5,4,3

D、5,4,3,2,1

因为中序的遍历结果就是升序排序所以可以得到中序后进行分析即可得出答案

编程实现如下

bool CanPostOrder(const int* a, int size)
{
	if (size <= 1)
		return true;

	int root = a[size - 1];
	int nLeft = 0;
	while (nLeft < size - 1)
	{
		if (a[nLeft] > root)
			break;
		nLeft++;
	}
	int nRight = size - 2; // size - 1是根
	while (nRight >= 0)
	{
		if (a[nRight] < root)
			break;
		nRight--;
	}
	if (nRight != nLeft - 1)   // 无法根据root分成两部分
		return false;

	return CanPostOrder(a, nLeft)                          // 左子树
		&& CanPostOrder(a + nLeft, size - nLeft - 1);      // 右子树
}

int _tmain(int argc, _TCHAR* argv[])
{
	int a[] = {1,2,5,4,3};
	bool b = CanPostOrder(a, sizeof(a) / sizeof(int));
	std::cout<<b<<endl;
	system("pause");
	return 0;
}




小小哇牛
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言visit函数作用,[求助]二叉树遍历的程序里面的visit函数如何实现
weixin_32540087的博客
05-16 5362
[求助]二叉树遍历的程序里面的visit函数如何实现我在没懂的后面加注释 希望大家指教#include#include#define MAXSIZE 100typedef struct binode{char data;struct binode *lchild;struct binode *rchild;}Binode;Binode* create(){char ch;Binode *t;sc...
算法之二叉查找树
独自登高楼 望断天涯路
10-09 1179
package com.eshore.sweetop.dataframe;import java.util.Random;import com.eshore.sweetop.data.KeyData;import com.eshore.sweetop.data.Node;/* * bintree */public class Bintree {    private Node root;
二叉树的遍历
always_to_run的博客
07-07 687
先序遍历（递归） 算法 二叉树为空，则空操作 二叉树非空，访问根节点（D），访问左子树（L），访问右子树（R） 代码 void PreOrderTraverse(BiTree T) //传递的参数为一棵树 { if(T==NULL) return ; //为空直接返回 else { visit(T); //访问根结点，可以写visit函数进行访问操作 PreOrderTraverse(T->Lchild); //递归遍历左子树 PreOrderTrave
二叉树的定义及基本操作
记昨日书
02-01 3348
二叉树的定义及基本操作 二叉树是另一种树形结构，它的特点是每个结点至多只有两棵子树，并且，二叉树的子树有左右之分，其次序不能任意颠倒。 1、InitBiTree（&T）； 操作结果：构造空二叉树 void InitBiTree(BiTree &T) { T=NULL; } 2、DestroyBiTree（&T） 初始条件：二叉树T存在 操作结果：销毁二叉树T voi
17 二叉树：前序、中序、后序遍历
Ultravioletrays的博客
04-19 1232
17二叉树：前序、中序、后序遍历 作者:冯向阳时间限制:1S章节:DS:树 截止日期:2022-06-30 23:55:00 问题描述 : 目的：使用C++模板设计并逐步完善二叉树的抽象数据类型（ADT）。 内容：（1）请参照链表的ADT模板，设计二叉树并逐步完善的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考教材、课件，以及网盘中的链表ADT原型文件，自行设计二叉树的ADT。） ...
二叉树遍历及其应用
q793145253的博客
01-10 1563
二叉树的三种遍历算法的递归实现 特别说明：函数形参中的 void(*visit)(BinTreeNode *p) 代表：采用一个visit的指针指向某个函数，该函数的形参为BinTreeNode *p，该函数的实现体中可以对结点进行处理，传参时将外部函数名传入即可 前、中、后的差别仅在于 visit(subTree) 该语句的位置不同 1、前序遍历 template<class T> void PreOrder(BinTreeNode<T> *subTree, void(*visit
算法——查找之二叉查找树
a60782885的博客
05-19 578
我们之前了解了二分查找，对于二分查找，仅仅盯着查找的话，二分查找确实是不错的。但是如果我们需要查找的数组，会改变呢？ 如果数组会改变，例如会删除其中某个元素，增加某个元素等。删除的话，如果需要删除的元素在数组的前面，那删除以后元素的移动又是一个很大的开销了。增加元素，也就是插入元素，需要再进行一次排序，开销也并不小。 所以能不能在保持查找效率的同时，数组的修改的开销也不大的方法呢？这就提到了二
c代码-二叉搜索树的删除操作
07-14
在IT领域，二叉搜索树（Binary Search Tree，简称BST）是一种常见的数据...理解并熟练掌握二叉搜索树的删除操作对于学习数据结构和算法是非常重要的，因为这涉及到如何高效地管理和操作数据，是计算机科学的基础之一。
算法-理论基础- 查找- 二叉排序树（包含源程序）.rar
09-16
二叉排序树，又称二叉查找树或二叉搜索树，是计算机科学中一种非常重要的数据结构，主要用于高效地进行查找、插入和删除操作。它具有以下特性：对于任意一个节点，其左子树中的所有节点的值都小于该节点的值，而右子...
c代码-二叉搜索树的查找操作
07-14
本主题将深入探讨如何使用C语言实现二叉搜索树的查找操作。 二叉搜索树的核心特点是每个节点的左子树只包含比该节点值小的元素，而右子树包含的元素则大于或等于该节点值。这种性质使得在二叉搜索树中查找、插入和...
c++实现二叉查找树示例
09-04
二叉查找树（Binary Search Tree，BST）是一种自平衡的二叉树，它具有以下特性：对于树中的每个节点，其左子树上的所有节点的值都小于该节点的值，而右子树上的所有节点的值都大于该节点的值。在C++中实现二叉查找树...
数据结构与算法设计课程设计-二叉排序树与平衡二叉树.docx
最新发布
06-28
二叉排序树，又称二叉查找树，是一种特殊的二叉树，满足以下性质：对于任意节点，其左子树中的所有节点的值均小于该节点，而右子树中的所有节点的值均大于该节点。这种结构使得查找、插入和删除操作的时间复杂度在...
7.数据结构C++学习笔记——树和二叉树
qq_46417568的博客
05-17 403
1. 1 树形结构结点之间有分支，具有层次关系树（Tree）是个结点的有限集。若n=0，称为空树。若n>0，则它满足如下两个条件：（1）有且只仅有一个特定的称为根（Root）的结点。（2）其余节点可分为m(m>=0)个互不相交的有限集T1,T2,T3...其中每一个集合本身又是一棵树，并称为根的子树（SubTree）。显然，树的定义是递归的定义。图 1.2.1 树的示意图个节点最多只有两个“叉”的树，普通树（多叉树）若不转为二叉树，则运算很难实现。
C语言 二叉树
m0_66460650的博客
12-05 956
#include #include typedef int DataType; typedef struct Node{ DataType data; struct Node *leftChild;//左孩子指针 struct Node *rightChild;//右孩子指针 }BiTreeNode; void visit(DataType item)//访问函数 { printf("%c ",item); } void Init
数据结构visit函数_第9篇： C++数据结构 二叉搜索树(前)
weixin_33634341的博客
01-29 1700
二叉查找树和前面所过的二叉堆在实现存在很大区别，在二叉搜索树(Binary Search Tree或者简称BST)中，任意节点的左子树中的所有节点的值要小于其右子树中的所有节点的值。二叉搜索树的性质：任一当前节点的左子树包含的节点值小于当前节点。任一当前节点的右子树包含的节点值大于当前节点。任意两个节点不能有重复的值。(这个性质非常重要，它使得BST可以构架另外一个数据结构Set，Set中每个元素...
函数指针的作用：*visit函数
photoresist的博客
03-10 9117
定义 函数指针是指向函数的指针变量。 因此“函数指针”本身首先应是指针变量，只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。如前所述，C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数，就如同用指针变量可引用其他类型变量一样，在这些概念上是大体一致的。函数指针有两个用途：调用函数和做函数的参数。 int f(elementtype x); //声明函数 int (*f1)(elemen
数据结构 二叉搜索树
vamesary的博客
04-15 387
在实际生活中，我们需要字典来查找字词，字典具有能够快速的在一个大的集合内寻找到一个元素的特征。在程序设计中我们也常常需要在一个大的集合中快速找到需要的元素，因此我们引入二叉搜索树，它可以在大小为n的集合中使得查找平均时间为logn，这大大提高了查询的效率。
二叉树相关操作（多使用递归）
weixin_48060069的博客
08-13 594
代码】二叉树相关代码。
算法学习-局部最大值
HelloNiGeSB的博客
11-23 5488
没时间了，以后补上

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值