真c++ 从二叉树到红黑树（1）之二叉树节点类及遍历详解

最新推荐文章于 2022-05-10 22:42:14 发布
最新推荐文章于 2022-05-10 22:42:14 发布
阅读量518 收藏 3
点赞数 2
分类专栏： C++数据结构与算法 文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bioinformatique/article/details/106061877
版权

  此文章为从二叉树到红黑树系列文章的第一节，主要介绍写这系列文章的起因，致谢邓老师，解释二叉树节点类和二叉树的四种遍历写法（包括递归和迭代写法）


文章目录

一、前言与致谢~（点击右边波浪线可以返回目录）

  c++是一门与时俱进的语言，纵观网上绝大多数c++的数据结构实现，都是c with class，不得不说，这样确实有利于理解和学习，但对于那些想借助数据结构来巩固c++的人来说，不由得有点遗憾（初学直接啃stl源码会直接自闭的）。

  在此，感谢清华的邓俊辉老师的c++数据结构教材和视频，多亏了邓老师的辛勤耕耘，我才有幸见到现代化的适用于初学者的c++数据结构代码。在邓老师教材的第五章，第七章和第八章，全部是介绍树的知识，看完和仿照敲完代码之后，获益匪浅，不止是对数据结构和算法的理解更深了一步，也对c++的特性掌握的更加牢固了一步。

  笔者将其代码中的一些特性进行了一些更新和修改，让其更符合现代风格。由于老师对堆区数据的回收都处理的很好，有的地方用智能指针的话，需要改比较多的东西，所以还是保持原来的new和delete。

  本系列文章为了方便，会引用教材和视频中的一些插图（侵删），虽然我对原代码进行了些许修改，但原代码所有权依然归邓老师所有。

  在写此系列文章的时候，笔者也对文章进行了排版，让其更容易进行阅读，大家放心阅读，笔者在适当的地方都留了空行和分段。（md的排版真心没word好= =，排个版都要敲代码！）

  本系列文章的所有代码，均在vs2019版本下编译通过，如果你无法编译过，请把编译器的c++版本开启c++17以上。

二、本系列文章内容基本介绍~

1.与邓老师原有代码对比~

我主要对以下几点进行了更新和修改

  1. 将所有的宏定义换成了c++11的constexpr和inline。有的换成了全局静态函数，有的换成了类中使用的函数。
  2. 大概是处于教学需要，邓公用的都是自定义的stack和queue，笔者就偷懒，直接用stl现成的stack和queue了，实现上大致相同。
  3. 将原来的某些代码进行了增减，这样更便于呈现主要内容。
  4. 所有主要代码都有迭代形式，主要代码流程中没有递归，有的代码会分别给出递归和迭代的形式，以便于理解。

2.主要流程（重点）~

笔者根据代码的内容不同，将分六部分来展现

  1. 基本二叉树节点，通用函数
  2. 基本二叉树类的定义和实现
  3. BST（二叉搜索树的实现）
  4. AVL（二叉平衡搜索树的实现）
  5. B树的实现（如果你只想了解B树，可以跳过所有章节，直接看B树）
  6. 红黑树的实现

  强烈建议按照流程进行浏览，只有这样，你才能真正了解红黑树！

  但若你没有时间，也没关系，我会在一些重点部分，涉及到之前知识点的地方弄一个提示，去指明你去哪才能看到相关的内容。

3.要看懂文章内的代码你需要了解的内容~

  1. 掌握c++的引用，指针，类的基本使用
  2. 知道什么是指针引用
  3. 了解命名空间，using声明，using别名。
  4. 了解c++的模板，仿函数的使用
  5. 熟悉stl中stack和queue容器的用法
  6. 对constexpr和inline不陌生
  7. 对树有一定的了解

  要完全看懂本系列文章，如果你是初次接触，不要妄想能在两三个小时内弄懂此系列文章所有内容，没人可以做的到，正确的方法是一天抽一两个小时研究其中一篇文章，对于红黑树可能需要更长的时间，你才能真正的看懂代码，如果你看过邓老师的教程的话，会更能体会到我这段话的意思。

  如果你嫌长，大可以看其他的文章，但我相信，弄懂本系列文章之后，不仅你的数据结构的功底，还是c++的功底，都可以更上一层楼。（针对c++初学者）。

三、树的语义规定~

1.树的高度与深度~

在此系列文章中，会大量用到树的高度和深度的概念，在此做一个强调

深度： 从根到该节点的唯一路径长，根的深度为0；从上到下数
高度： 从该节点到叶节点的最长路径长，所有树叶的高度为0；从下往上数

另外，规定空树的高度为-1。

所以，若只有根节点存在，根节点的高度为0。

2.树的遍历~

在这里插入图片描述

（1）树的先序遍历~

先访问根节点，再依次遍历左子树和右子树
即根左右（一直左到底再右）
3102546

（2）树的中序遍历~

先访问左子树，再依次遍历根和右子树
即左根右（即将各个节点映射到一条直线上）
0123456

（3）树的后序遍历~

先访问左子树，再依次遍历右子树和根
即左右根
0214653

（4）树的层次遍历~

从上而下，从左到右访问树中各个节点
3150246

四、基本二叉树节点类~

（一）定义变量和接口~

1.需要的变量~

T _data;//存放数据
BinNodePtr _parent;
BinNodePtr _lchild;
BinNodePtr _rchild;
int _height;//高度（通用）
RBColor _color;//红黑树专用

2.需要的接口~

四种遍历
取得当前节点的直接后继（BST，AVL，RedBlack用）

3.其他辅助函数~

判等器等操作符重载

4.BinNode.h~

	namespace {
		enum class RBColor { RED, BLACK };
	}

	//===二叉树节点类===//
	template<typename T = int>
	class BinNode {

	public:
		using BinNodePtr = BinNode<T>*;

	public:
		T _data;//存放数据
		BinNodePtr _parent;
		BinNodePtr _lchild;
		BinNodePtr _rchild;
		int _height;//高度（通用）
		RBColor _color;//红黑树专用

	public:
		BinNode() :_data(0), _parent(nullptr),_lchild(nullptr), _rchild(nullptr), _height(0), _color(RBColor::RED) {}

		BinNode(
			const T& data, 
			const BinNodePtr parent = nullptr, 
			const BinNodePtr lchild=nullptr, 
			const BinNodePtr rchild=nullptr,
			const int &height=0, 
			const RBColor& color = RBColor::RED)
			:_data(data), _parent(parent), _lchild(lchild), _rchild(rchild),_height(height),_color(color) {}

	public:
		constexpr bool operator==(const BinNode& bN)const {
			return this->_data == bN._data;
		}

		constexpr bool operator!=(const BinNode& bN)const {
			return !(this->_data == bN._data);
		}

		constexpr bool operator<(const BinNode& bN)const {
			return this->_data < bN._data;
		}

		constexpr bool operator>(const BinNode& bN)const {
			return this->_data > bN._data;
		}

		constexpr bool operator<=(const BinNode& bN)const {
			return !(this->_data > bN._data);
		}

		constexpr bool operator>=(const BinNode& bN)const {
			return !(this->_data < bN._data);
		}
	public:

		BinNodePtr succ();//取得中序遍历当前节点的直接后继，必然无左孩子

	public:
		template <typename VST> void travLevel(VST); //子树层次遍历

		template <typename VST> void travPre(VST,const int &method=1); //子树先序遍历

		template <typename VST> void travPost(VST,const int&method=1); //子树后序遍历

		template <typename VST> void travIn(VST,const int&method=1); //子树中序遍历

	};//class BinNode

（二）通用全局静态函数（不包含后面代码就运行不了哦）~

  邓老师书上的宏定义有很多个，我将用的多的封装成相应的constexpr和inline函数，将用的少的放入对应的树的类中，这样更有利于管理和应用。

BInNode_Macro.h~

#pragma once

/******************************************************************************************
 * BinNode状态与性质的判断
 ******************************************************************************************/

#include<algorithm>
using std::max;

namespace mytree_marcro {
    template<typename BinNodePtr>
    static constexpr bool IsRoot(const BinNodePtr& x) {
        return !(x->_parent);
    }

    template<typename BinNodePtr>
    static constexpr bool IsLChild(const BinNodePtr& x) {
        return (!IsRoot(x) && (x == x->_parent->_lchild));
    }

    template<typename BinNodePtr>
    static constexpr bool IsRChild(const BinNodePtr& x) {
        return (!IsRoot(x) && (x == x->_parent->_rchild));//不是根节点，并且其地址跟其父亲的右孩子地址相同
    }


    template<typename BinNodePtr>
    static constexpr bool HasLChild(const BinNodePtr& x) {
        return (x == nullptr) ? false : x->_lchild;
	}

    template<typename BinNodePtr>
    static constexpr bool HasRChild(const BinNodePtr& x) {
        return (x == nullptr) ? false : x->_rchild;
	}

    template<typename BinNodePtr>
    static constexpr int stature(const BinNodePtr& x) {//获取高度
        return x ? x->_height : -1;//空指针高度为-1
    }

}// namespace mytree_marcro

（三）树的四种遍历~

（重点）借助仿函数来实现遍历的高明方法~

  对于老手和善用stl的人而言， 这种利用回调函数来进行访问对应节点的方式，再正常不过。在邓老师的遍历代码中，就高明的用了这种方式，通过这种高内聚，低耦合的方式，从而能对节点进行更多的操作，而并非仅仅是cout就完事。在之后的BST，AVL和RedBlack中，我都会提供一些测试用的仿函数，读者可根据自己的需要进行改进。

1.层次遍历的队列写法~

  根节点入队，然后弹出根节点，并将其左右节点入队。直至队列为空。
在这里插入图片描述

template<typename T>template<typename VST>
void BinNode<T>::travLevel(VST visit) {
	if (this == nullptr)//提前判断是否为空树
		return;
	queue<BinNodePtr> Q;
	Q.push(this);//根节点入队
	BinNodePtr current = nullptr;//防止多次调用构造析构，故在循环为创建临时变量
	while (!Q.empty()) {//如果队列不为空
		current = Q.front();
		visit(current);
		Q.pop();
		if (HasLChild(current))
			Q.push(current->_lchild);
		if (HasRChild(current))
			Q.push(current->_rchild);
	}
}

2.先序遍历~

（1）先序遍历选择接口~

由于有三种先序遍历的写法，因此创建一个接口函数，并且默认调用迭代版的先序遍历

template<typename T>template<typename VST>
void BinNode<T>::travPre(VST visit,const int& method) {

	using mytree_trav::travPre_1;
	using mytree_trav::travPre_2;
	using mytree_trav::travPre_R;

	if (this == nullptr)//提前判断是否为空树
		return;
	switch (method)
	{
	case 0:travPre_1(this, visit); break;
	case 1:travPre_2(this, visit); break;
	default:travPre_R(this, visit); break;
	}
}
（2）先序遍历的递归写法~

以根左右的顺序，进行递归先序遍历

/*先序遍历递归版*/
template<typename BinNodePtr, typename VST>
static void travPre_R(BinNodePtr x, VST visit) {
	if (x == nullptr)
		return;
	visit(x);
	travPre_R(x->_lchild, visit);
	travPre_R(x->_rchild, visit);
}
（3）先序遍历借助栈的迭代写法1~

  尾递归转化为循环。如果只有一个递归体，那么直接转循环就可以。因为此处有两个递归体，因此，还需要借助一个辅助栈来实现。

  递归时，分成3部分来看，第一部分基本语句，第二部分递归调用左孩子，第三部分递归调用右孩子。
  从递归时函数调用的堆栈分析来看，相当于先把最后一个语句，也就是遍历右孩子入栈，再把倒数第二个语句，也就是遍历左孩子入栈，下一步就是取出栈顶元素进行遍历。重复循环。（理解了此点，你就能很快的理解为什么需要一个辅助栈！）

在这里插入图片描述

//-----------先序遍历--------------//
/*迭代版1*//*递归转迭代*//*此法与迭代2在效率上，没什么区别，但是此法只适用于先序
 *而迭代2的方式，可以适用于中序和后序遍历*/
template<typename BinNodePtr, typename VST>
static void travPre_1(BinNodePtr x, VST visit) {
	stack<BinNodePtr> S;
	S.push(x);
	while (!S.empty()) {
		x = S.top();
		S.pop();
		visit(x);
		if (HasRChild(x))//入栈次序为先右后左
			S.push(x->_rchild);
		if (HasLChild(x))
			S.push(x->_lchild);
	}
}
（4）先序遍历借助栈的迭代写法2–便于理解中序和后序的迭代写法~

在这里插入图片描述

  从书上虚线的的路径，不难发现遍历过程中的一个套路，即遍历可以等价的理解成，从当前节点从上到下访问左子树，并visit对应的节点，直到访问到左子树为空为止，同时在途中将右孩子均存入栈中。当左子树访问到根节点时，就取出栈顶元素，继续做一次从上到下的向左遍历。

在这里插入图片描述

/*迭代版2*/
template<typename BinNodePtr, typename VST>
static void visitLeft_Pre(BinNodePtr x, VST visit, stack<BinNodePtr>& S) {
	while (x) {
		visit(x);//访问当前节点
		if (HasRChild(x))//右孩子入栈暂存
			S.push(x->_rchild);
		x = x->_lchild;
	}
}

template<typename BinNodePtr, typename VST>
static void travPre_2(BinNodePtr x, VST visit) {
	stack<BinNodePtr> S;
	while (true) {
		visitLeft_Pre(x, visit, S);//从当前节点出发，从上到下，向左访问。
		if (S.empty())//直到栈空
			break;
		x = S.top();//若栈不空，则取出栈顶节点继续循环
		S.pop();
	}
}

3.中序遍历~

（1）中序遍历选择接口~

由于有三种中序遍历的写法，因此创建一个接口函数，并且默认调用迭代版的中序遍历

template<typename T>template<typename VST>
void BinNode<T>::travIn(VST visit, const int& method) {

	using mytree_trav::travIn_1;
	using mytree_trav::travIn_2;
	using mytree_trav::travIn_R;

	if (this == nullptr)//提前判断是否为空树
		return;
	switch (method)
	{
	case 1:travIn_1(this, visit); break;//1相对普通树最快
	case 2:travIn_2(this, visit); break;
	default:travIn_R(this, visit); break;
	}
}
（2）中序遍历的递归写法~

以左根右的顺序，进行递归中序遍历

/*递归版*/
template<typename BinNodePtr,typename VST>
static void travIn_R(BinNodePtr x, VST visit) {
	if (x == nullptr)
		return;
	travIn_R(x->_lchild,visit);
	visit(x);
	travIn_R(x->_rchild,visit);
}
（3）中序遍历借助栈的迭代写法~

在这里插入图片描述
  从上图可以看出，我们遍历时第一个访问的必然是最左边的节点a，但我们的传入的节点一般为根节点，即都是从i开始进行中序遍历的。因此，首先也必须要到最左边的节点a，即要做一次从上到下的向左访问左子树，而沿途的节点都不妨存入栈中，方便之后使用。

  每从栈中弹出一个节点，就对其进行visit，都需要对其有没有右孩子进行检查，如果有右孩子，则右孩子入栈，并且对右孩子也做一次从上到下的向左遍历，将沿途的节点全部存入栈中。

  这样一直到栈为空为止。
在这里插入图片描述

//---------中序遍历---------//
template<typename BinNodePtr>
static void visitLeft_In(BinNodePtr x, stack<BinNodePtr>& S) {//将所有左孩子插入栈中
	while (x) {
		S.push(x);
		x = x->_lchild;
	}
}

/*迭代版1*/
template<typename BinNodePtr, typename VST>
static void travIn_1(BinNodePtr x, VST visit) {
	stack<BinNodePtr> S;
	while (true) {
		visitLeft_In(x, S);//将所有左孩子插入栈中
		if (S.empty())
			break;
		x = S.top();

		visit(x);
		S.pop();
		x = x->_rchild;//如果栈顶元素有右孩子，则对右孩子的左子树进行visitLeft_In，若右孩子为空，则直接结束visitLeft_In
	}
}
（4）中序遍历不借助栈的迭代写法–在理解了怎么求直接后继后再来看~

  本方法实际上本人不推荐使用，因为其每一次遍历都需要去求后继，无疑相对前面一种迭代方法而言，增加了不必要的代价。

  因此，此法有兴趣者可以看看。此法最重要的是一种利用后继来遍历的思想，这点对于线索二叉树而言非常有效。有兴趣的读者可以看看本人按照大话数据结构改编的线索二叉树的c++代码https://blog.csdn.net/bioinformatique/article/details/106082423

/*迭代版2*/
template<typename BinNodePtr, typename VST>
static void travIn_2(BinNodePtr x, VST visit) {
	while (true) {
		if (HasLChild(x)) {//若有左子树，则
			x = x->_lchild;//深入左子树
		}
		else {
			visit(x);//访问当前节点，并
			while (!HasRChild(x)) {//不断地在无右分支处
				if (x = x->succ())//回溯至直接后继,注意此处为赋值
					visit(x);//如果有后继，则访问
				else
					return; //（在没有后继的末节点处，直接退出）
			}
			x = x->_rchild;//（直至有右分支处）转向非空的右子树
		}
	}
}

4.后序遍历~

（1）后序遍历选择接口~

由于有两种后序遍历的写法，因此创建一个接口函数，并且默认调用迭代版的后序遍历

template<typename T>template<typename VST>
void BinNode<T>::travPost(VST visit, const int& method) {

	using mytree_trav::travPost_1;
	using mytree_trav::travPost_R;

	if (this == nullptr)//提前判断是否为空树
		return;
	switch (method)
	{
	case 1:travPost_1(this, visit); break;
	default:travPost_R(this, visit); break;
	}
}
（2）后序遍历的递归写法~

以左右根的顺序，进行递归后序遍历

/*递归版*/
template<typename BinNodePtr, typename VST>
static void travPost_R(BinNodePtr x, VST visit) {
	if (x == nullptr)
		return;
	travPost_R(x->_lchild, visit);
	travPost_R(x->_rchild, visit);
	visit(x);
}
（3）后序遍历借助栈的迭代写法~

在这里插入图片描述
  后序遍历与中序和先序遍历不同的是，后序遍历的第一个被访问的节点稍有不同，其没有先序（必然为根节点）和中序（必然为最左孩子）这样的规律性。

  1. 若最左边孩子没有右子树（最左边孩子显然没有左子树），则最左边节点是第一个被访问的节点。
  2. 若最左边孩子有右子树，则是最左边的节点的右子树的最左边的节点。

  首先，无论如何，都需要找到第一个节点。并且沿途的节点也要像中序和前序遍历一样很好地利用起来。幸运的是，邓老师已经帮我们解决了这个难题。

a）找到当前子树后续遍历的第一个节点~

  方法就是从当前节点开始，先看其有没有右孩子，如果有右孩子，则将右孩子入栈，然后再看有没有左孩子，如果有左孩子，则将左孩子再入栈，并且将左孩子当做“当前节点”继续循环。

  如果当前节点没有左孩子，则看这个节点的右孩子有没有孩子，如果这个节点的右孩子有孩子，则把这个节点作为“当前节点”，继续进行循环。

  直到“当前节点”没有孩子为止。那么，此时的栈顶元素，必将为当前树（子树）的后序遍历应该访问的第一个节点。

如下图，第一个节点显然是a

在这里插入图片描述
在这里插入图片描述
代码实现为

template<typename BinNodePtr>
static void visitLeft_Post(stack<BinNodePtr>& S) {
	BinNodePtr x = S.top();//将栈顶节点作为当前节点
	while (true) {//判断是否有左右孩子，并且先插入右孩子
		if (HasRChild(x)) {
			S.push(x->_rchild);
		}
		if (HasLChild(x)) {
			S.push(x->_lchild);
		}
		if (x == S.top())//说明栈没有插入任何元素，即抵达此子树应该被访问的第一个节点
			break;
		x = S.top();//否则就将栈顶元素给当前的x
	}
}
b) 主遍历函数~

  在解决了找到当前子树的相对后继遍历的第一个节点后，就解决了后继遍历的绝大多数问题。并且，并非在遍历过程中，所有的节点都需要去执行visitLeft_Post函数。

再来观看此图，以及此时的栈结构

在这里插入图片描述
在这里插入图片描述
我们需要对b进行一次visitLeft_Post函数么，显然不需要，因为其没有左子树。
因此直接访问b。
在这里插入图片描述
下一个被访问的元素为G么？，显然不是G，其左右子树也都没有在栈中，因此，我们需要以G为子树进行一次visitLeft_Post函数，从而找到c。
在这里插入图片描述
从上面3个图可以看出，访问b前不需要进行visitLeft_Post函数，访问c时需要进行visitLeft_Post函数。那么，到底什么时候需要进行visitLeft_Post函数？

  不妨看一下父子关系。b是a的父亲，而G不是b的父亲，反而，G是b的兄弟节点！

  不妨可以得出结论，只有当此时栈顶元素不是刚刚弹出的栈顶元素的父亲时（必然为刚弹出元素的兄弟），才会进行visitLeft_Post函数，将新的节点插入栈中。

下面给出后序遍历迭代版的算法

/*迭代版*/
template<typename BinNodePtr, typename VST>
static void travPost_1(BinNodePtr x, VST visit) {
	stack<BinNodePtr> S;
	S.push(x);
	while (!S.empty()) {
		//若栈顶节点不是父亲节点，即必为其兄弟节点（除了根节点以外），
		//若为其兄弟节点，则对兄弟节点进行visitLeft_Post的操作。
		if (S.top() != x->_parent)
			visitLeft_Post(S);
		visit(S.top());
		x = S.top();//将x设为栈顶元素
		S.pop();
	}
}
c）后序遍历迭代算法完整版~
//--------------后序遍历--------------//
template<typename BinNodePtr>
static void visitLeft_Post(stack<BinNodePtr>& S) {
	BinNodePtr x = S.top();//将栈顶节点作为当前节点
	while (true) {//判断是否有左右孩子，并且先插入右孩子
		if (HasRChild(x)) {
			S.push(x->_rchild);
		}
		if (HasLChild(x)) {
			S.push(x->_lchild);
		}
		if (x == S.top())//说明栈没有插入任何元素，即抵达此子树应该被访问的第一个节点
			break;
		x = S.top();//否则就将栈顶元素给当前的x
	}
}

/*迭代版*/
template<typename BinNodePtr, typename VST>
static void travPost_1(BinNodePtr x, VST visit) {
	stack<BinNodePtr> S;
	S.push(x);
	while (!S.empty()) {
		//若栈顶节点不是父亲节点，即必为其兄弟节点（除了根节点以外），
		//若为其兄弟节点，则对兄弟节点进行visitLeft_Post的操作。
		if (S.top() != x->_parent)
			visitLeft_Post(S);
		visit(S.top());
		x = S.top();//将x设为栈顶元素
		S.pop();
	}
}

（四）求当前节点的直接后继（用于中序遍历）~

succ()取得当前节点的后继节点

  与所有遍历一样，中序遍历的实质功能也可理解为，为所有节点赋予一个次序，从而将半线性的二叉树转化为线性结构。于是一旦指定了遍历策略，即可与向量和列表一样，在二叉树的节点之间定义后继关系。其中没有后继）的节点称作末节点。

  对于后面将要介绍的BST，AVL，RedBlack，中序遍历的作用至关重要。相关算法必需的一项基本操作，就是定位任一节点在中序遍历序列中的直接后继。

  分析一个节点的后继，不妨分做两种情况分别进行考虑。

（1）若当前节点有右孩子，则其直接后继必然存在，且属于其右子树。~

  在这种情况下，当前节点的直接后继，必然没有左孩子。

如下图a的右孩子b存在，b没有左孩子，即b为a的直接后继

在这里插入图片描述

如下图d的右孩子h存在，h有左孩子，即e为d的直接后继

在这里插入图片描述

（2）若当前节点没有右孩子，则其直接后继若存在，并为其祖先。~

如下图b的右孩子不存在，则其直接后继若存在，必为其某一祖先，即c为b的直接后继

在这里插入图片描述

如下图p的右孩子不存在，但其已经为全树的最右节点，因此其没有后继

在这里插入图片描述

读者们可以根据中序遍历来进一步体会节点的后继

在这里插入图片描述

（3）后继节点代码~

//-------取得当前节点的直接后继----------//
template<typename T>
BinNode<T>* BinNode<T>::succ() {
	using BinNodePtr = BinNode<T>*;
	BinNodePtr s = this;
	if (HasRChild(s)) {//当前节点有右孩子
		s = s->_rchild;
		while (HasLChild(s))//这个右孩子有没有左孩子，直到没有左孩子为止
			s = s->_lchild;
	}
	else {
		//必须分是否是右孩子来判断，因为这对应不同的情况，如果这个节点不为右孩子，则返回其父亲
		//如果这个节点是右孩子，则需要不断向上找其父亲，直到不为右孩子为止（即为左孩子或根节点)
		while (IsRChild(s))
			s = s->_parent;
		s = s->_parent;//再往上找一格，就能找到后继。//当然，如果已经到了根节点，根节点的父亲当然为空。所以返回空。同时也说明这个节点是最后一个节点。
	}
	return s;
}

（五）BinNode.h完整代码~

#pragma once

#include<queue>
#include<stack>
#include "BinNode_Macro.h"

using std::queue;
using std::stack;

namespace mytree {

	using namespace mytree_marcro;

	namespace {
		enum class RBColor { RED, BLACK };
	}

	//===二叉树节点类===//
	template<typename T = int>
	class BinNode {

	public:
		using BinNodePtr = BinNode<T>*;

	public:
		T _data;//存放数据
		BinNodePtr _parent;
		BinNodePtr _lchild;
		BinNodePtr _rchild;
		int _height;//高度（通用）
		RBColor _color;//红黑树专用

	public:
		BinNode() :_data(0), _parent(nullptr),_lchild(nullptr), _rchild(nullptr), _height(0), _color(RBColor::RED) {}

		BinNode(
			const T& data, 
			const BinNodePtr parent = nullptr, 
			const BinNodePtr lchild=nullptr, 
			const BinNodePtr rchild=nullptr,
			const int &height=0, 
			const RBColor& color = RBColor::RED)
			:_data(data), _parent(parent), _lchild(lchild), _rchild(rchild),_height(height),_color(color) {}

	public:
		constexpr bool operator==(const BinNode& bN)const {
			return this->_data == bN._data;
		}

		constexpr bool operator!=(const BinNode& bN)const {
			return !(this->_data == bN._data);
		}

		constexpr bool operator<(const BinNode& bN)const {
			return this->_data < bN._data;
		}

		constexpr bool operator>(const BinNode& bN)const {
			return this->_data > bN._data;
		}

		constexpr bool operator<=(const BinNode& bN)const {
			return !(this->_data > bN._data);
		}

		constexpr bool operator>=(const BinNode& bN)const {
			return !(this->_data < bN._data);
		}
	public:

		BinNodePtr succ();//取得中序遍历当前节点的直接后继，必然无左孩子

	public:
		template <typename VST> void travLevel(VST); //子树层次遍历

		template <typename VST> void travPre(VST,const int &method=1); //子树先序遍历

		template <typename VST> void travPost(VST,const int&method=1); //子树后序遍历

		template <typename VST> void travIn(VST,const int&method=1); //子树中序遍历

	};//class BinNode

	//--------------遍历------------------//
	namespace mytree_trav {
		//-----------先序遍历--------------//
		/*迭代版1*//*递归转迭代*//*此法与迭代2在效率上，没什么区别，但是此法只适用于先序
		 *而迭代2的方式，可以适用于中序和后序遍历*/
		template<typename BinNodePtr, typename VST>
		static void travPre_1(BinNodePtr x, VST visit) {
			stack<BinNodePtr> S;
			S.push(x);
			while (!S.empty()) {
				x = S.top();
				S.pop();
				visit(x);
				if (HasRChild(x))//入栈次序为先右后左
					S.push(x->_rchild);
				if (HasLChild(x))
					S.push(x->_lchild);
			}
		}

		/*迭代版2*/
		template<typename BinNodePtr, typename VST>
		static void visitLeft_Pre(BinNodePtr x, VST visit, stack<BinNodePtr>& S) {
			while (x) {
				visit(x);//访问当前节点
				if (HasRChild(x))//右孩子入栈暂存
					S.push(x->_rchild);
				x = x->_lchild;
			}
		}

		template<typename BinNodePtr, typename VST>
		static void travPre_2(BinNodePtr x, VST visit) {
			stack<BinNodePtr> S;
			while (true) {
				visitLeft_Pre(x, visit, S);//从当前节点出发，从上到下，向左访问。
				if (S.empty())//直到栈空
					break;
				x = S.top();//若栈不空，则取出栈顶节点继续循环
				S.pop();
			}
		}

		/*先序遍历递归版*/
		template<typename BinNodePtr, typename VST>
		static void travPre_R(BinNodePtr x, VST visit) {
			if (x == nullptr)
				return;
			visit(x);
			travPre_R(x->_lchild, visit);
			travPre_R(x->_rchild, visit);
		}

		//--------------后序遍历--------------//
		template<typename BinNodePtr>
		static void visitLeft_Post(stack<BinNodePtr>& S) {
			BinNodePtr x = S.top();//将栈顶节点作为当前节点
			while (true) {//判断是否有左右孩子，并且先插入右孩子
				if (HasRChild(x)) {
					S.push(x->_rchild);
				}
				if (HasLChild(x)) {
					S.push(x->_lchild);
				}
				if (x == S.top())//说明栈没有插入任何元素，即抵达此子树应该被访问的第一个节点
					break;
				x = S.top();//否则就将栈顶元素给当前的x
			}
		}

		/*迭代版*/
		template<typename BinNodePtr, typename VST>
		static void travPost_1(BinNodePtr x, VST visit) {
			stack<BinNodePtr> S;
			S.push(x);
			while (!S.empty()) {
				//若栈顶节点不是父亲节点，即必为其兄弟节点（除了根节点以外），若为其兄弟节点，则对兄弟节点进行visitLeft_Post的操作。
				if (S.top() != x->_parent)
					visitLeft_Post(S);
				visit(S.top());
				x = S.top();//将x设为栈顶元素
				S.pop();
			}
		}

		/*递归版*/
		template<typename BinNodePtr, typename VST>
		static void travPost_R(BinNodePtr x, VST visit) {
			if (x == nullptr)
				return;
			travPost_R(x->_lchild, visit);
			travPost_R(x->_rchild, visit);
			visit(x);
		}

		//---------中序遍历---------//
		template<typename BinNodePtr>
		static void visitLeft_In(BinNodePtr x, stack<BinNodePtr>& S) {//将所有左孩子插入栈中
			while (x) {
				S.push(x);
				x = x->_lchild;
			}
		}

		/*迭代版1*/
		template<typename BinNodePtr, typename VST>
		static void travIn_1(BinNodePtr x, VST visit) {
			stack<BinNodePtr> S;
			while (true) {
				visitLeft_In(x, S);//将所有左孩子插入栈中
				if (S.empty())
					break;
				x = S.top();

				visit(x);
				S.pop();
				x = x->_rchild;//如果栈顶元素有右孩子，则对右孩子的左子树进行visitLeft_In，若右孩子为空，则直接结束visitLeft_In
			}
		}

		/*迭代版2*/
		template<typename BinNodePtr, typename VST>
		static void travIn_2(BinNodePtr x, VST visit) {
			while (true) {
				if (HasLChild(x)) {//若有左子树，则
					x = x->_lchild;//深入左子树
				}
				else {
					visit(x);//访问当前节点，并
					while (!HasRChild(x)) {//不断地在无右分支处
						if (x = x->succ())//回溯至直接后继,注意此处为赋值
							visit(x);//如果有后继，则访问
						else
							return; //（在没有后继的末节点处，直接退出）
					}
					x = x->_rchild;//（直至有右分支处）转向非空的右子树
				}
			}
		}

		/*递归版*/
		template<typename BinNodePtr,typename VST>
		static void travIn_R(BinNodePtr x, VST visit) {
			if (x == nullptr)
				return;
			travIn_R(x->_lchild,visit);
			visit(x);
			travIn_R(x->_rchild,visit);
		}

	}//namespace mytree_trav

	template<typename T>template<typename VST>
	void BinNode<T>::travLevel(VST visit) {
		if (this == nullptr)//提前判断是否为空树
			return;
		queue<BinNodePtr> Q;
		Q.push(this);//根节点入队
		BinNodePtr current = nullptr;//防止多次调用构造析构，故在循环为创建临时变量
		while (!Q.empty()) {//如果队列不为空
			current = Q.front();
			visit(current);
			Q.pop();
			if (HasLChild(current))
				Q.push(current->_lchild);
			if (HasRChild(current))
				Q.push(current->_rchild);
		}
	}

	template<typename T>template<typename VST>
	void BinNode<T>::travPre(VST visit,const int& method) {

		using mytree_trav::travPre_1;
		using mytree_trav::travPre_2;
		using mytree_trav::travPre_R;

		if (this == nullptr)//提前判断是否为空树
			return;
		switch (method)
		{
		case 0:travPre_1(this, visit); break;
		case 1:travPre_2(this, visit); break;
		default:travPre_R(this, visit); break;
		}
	}

	template<typename T>template<typename VST>
	void BinNode<T>::travPost(VST visit, const int& method) {

		using mytree_trav::travPost_1;
		using mytree_trav::travPost_R;

		if (this == nullptr)//提前判断是否为空树
			return;
		switch (method)
		{
		case 1:travPost_1(this, visit); break;
		default:travPost_R(this, visit); break;
		}
	}

	template<typename T>template<typename VST>
	void BinNode<T>::travIn(VST visit, const int& method) {

		using mytree_trav::travIn_1;
		using mytree_trav::travIn_2;
		using mytree_trav::travIn_R;

		if (this == nullptr)//提前判断是否为空树
			return;
		switch (method)
		{
		case 1:travIn_1(this, visit); break;//1相对普通树最快
		case 2:travIn_2(this, visit); break;
		default:travIn_R(this, visit); break;
		}
	}

	//-------取得当前节点的直接后继----------//
	template<typename T>
	BinNode<T>* BinNode<T>::succ() {
		using BinNodePtr = BinNode<T>*;
		BinNodePtr s = this;
		if (HasRChild(s)) {//当前节点有右孩子
			s = s->_rchild;
			while (HasLChild(s))//这个右孩子有没有左孩子，直到没有左孩子为止
				s = s->_lchild;
		}
		else {
			//必须分是否是右孩子来判断，因为这对应不同的情况，如果这个节点不为右孩子，则返回其父亲
			//如果这个节点是右孩子，则需要不断向上找其父亲，直到不为右孩子为止（即为左孩子或根节点)
			while (IsRChild(s))
				s = s->_parent;
			s = s->_parent;//再往上找一格，就能找到后继。//当然，如果已经到了根节点，根节点的父亲当然为空。所以返回空。同时也说明这个节点是最后一个节点。
		}
		return s;
	}
}//namespace mytree

五.后序文章链接~

  1. 基本二叉树节点，通用函数 二叉树节点
  2. 基本二叉树类的定义和实现 二叉树基类
  3. BST（二叉搜索树的实现） BST
  4. AVL（二叉平衡搜索树的实现）AVL
  5. B树的实现（如果你只想了解B树，可以跳过所有章节，直接看B树）B树
  6. 红黑树的实现 RedBlack

学一个东西，不知道其道理，不高明！

天翔龙闪
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
IT笔试面试--红黑树详细解析，代码+图解
04-14
"红黑树详解" 红黑树是一种自平衡二叉查找树，它的统计性能要好于平衡二叉树（AVL 树），因此，红黑树在很多地方都有应用。在 C++ STL 中，很多部分（包括 set, multiset, map, multimap）应用了红黑树的变体（SGI ...
BST:C++ 中的 BST
07-08
为了保持高效性，可以使用自平衡二叉搜索树，如AVL树或红黑树。 总结，二叉搜索树在C++中是一种常用的动态数据结构，其核心优势在于对数据的高效检索。正确理解和实现BST的插入、删除、搜索和遍历等操作是C++数据...
C++ STL和平衡二叉树红黑树
无敌秋
03-31 2035
在实际使用过程中，到底选择这几种容器中的哪一个，应该根据遵循以下原则： １、如果需要高效的随机存取，不在乎插入和删除的效率，使用vector； 2、如果需要大量的插入和删除元素，不关心随机存取的效率，使用list； 3、如果需要随机存取，并且关心两端数据的插入和删除效率，使用deque； 4、如果打算存储数据字典，并且要求方便地根据key找到value，一对一的情况使用map，一对多的情况使用multimap； 5、如果打算查找一个元素是否存在于某集合中，唯一存在的情况使用set，不唯一存在的情况使用mul
【C++】【二叉树】【红黑树】构建RB tree、红黑树 类
多丰富下自己呀
06-25 217
文章目录前言1、红黑树定义2、红黑树性能3、红黑树特点一、重点解析1、插入规则1、1、插入节点旁没有红色节点：1、2、插入节点周围有红色节点：2、左旋转、右旋转3、颜色翻转4、插入节点5、析构函数二、完整红黑树类参考 前言 1、红黑树定义 ○ 每个节点或是红色，或是黑色。 ○ 根节点是黑色。 ○ 每个叶子节点（最后的空节点，和以前的叶子节点概念不一样）是黑色的。 ○ 红色节点的孩子是黑色的。 任意节点到叶子节点，经过的黑色节点数是一样的。 2、红黑树性能 完全随机的数据，二分搜索树就很好用了。极端情况会
c++的二叉树
客舟中
01-01 1万+
目录 二叉树的定义 二叉树的分类 1. 完全二叉树 2. 满二叉树 3. 斜树 4. 二叉搜索树 5. 平衡二叉树 二叉树的存储方式 1. 数组存储 2. 链表存储 二叉树的遍历方式 1. 前序遍历 2. 中序遍历 3. 后序遍历 4. 层序遍历 二叉树的代码实现 总结 技术参考 二叉树的定义 二叉树是每个节点最多只有两个子树的数结构，两个子树称为左子树和右子树。 二叉树的分类 1. 完全二叉树 假设其深度为 d（d>1）。除了第 d 层外....
二叉树详解（C++）
qq_54169998的博客
11-04 9367
树状图是一种数据结构，它是由 n（n>=1）个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 每个结点有零个或多个子结点；没有父结点的结点称为根结点；每一个非根结点有且只有一个父结点；除了根结点外，每个子结点可以分为多个不相交的子树； 专业术语 中 文 描 述 根节点 一棵树的顶点 孩子节点 一个结点含有的子树的根结点称为该结点的子结点 叶子节点 .
学生信息管理系统,学生信息管理系统查询,C,C++
09-10
1. 数据结构选择：考虑到信息查询的效率，一般会选择二叉树作为数据结构，尤其是平衡二叉搜索树（如AVL树或红黑树），因为它们支持快速的查找、插入和删除操作。 2. 二叉树遍历：为了实现学生信息的增删查，我们需要...
c++容器list、vector、map、set区别与用法详解
08-19
"c++容器list、vector、map、set区别与用法详解" c++容器是c++标准模板库（STL）中的一个重要组件，提供了多种数据结构的实现，包括list、vector、map、set等。这些容器的使用可以大大提高开发效率和代码可读性。 ...
chazhao.rar_数据结构_Visual_C++_
08-12
程序员需要定义一个二叉树节点类，包含节点值、左右子节点指针，并提供插入、查找和删除的方法。同时，为了防止内存泄漏，需要正确管理节点的创建和销毁。 总之，这个压缩包提供的程序代码可以帮助我们深入理解数据...
红黑树的完整实现（C++）
06-26
红黑树的完整实现（C++）模板类；已测试使用完毕。参考《STL源码剖析》《算法导论》
C++实现树 - 02 二叉树
Newin2020的博客
05-04 5354
写在前面： 这一讲我们来看看二叉树的实现，还不清楚树的结构的小伙伴建议先看看上面一讲关于树的定义。 二叉树的定义 二叉树是每个结点最多有两个子树的树结构。也就是说二叉树不允许存在度大于2的树。它有五种最基本的形态：二叉树可以是空集。根可以有空的左自树或者右子树；或者左右子树都是空。其中只有左子树或者右子树的叫做斜树。 二叉树的主要性质 性质 结论 性质一 在二叉树的 i 层上至多有 2 ^ ( i - 1 ) 个结点（ i >= 1 ） 性质二 深度为 k 的二叉树至多有 2.
B树，B+树的原理及区别
07-29 248
如图所示，区别有以下两点： 　　1. B+树中只有叶子节点会带有指向记录的指针（ROWID），而B树则所有节点都带有，在内部节点出现的索引项不会再出现在叶子节点中。 　　2. B+树中所有叶子节点都是通过指针连接在一起，而B树不会。 B树的原理： 　　就是为了存储设备或者磁盘设计的一种平衡查找树；通过对树高度的降低可以提升查找效率，尤其是在大量数据进行存储的时候会存储到...
红黑树（C++实现）
2021dragon的博客
12-06 1万+
红黑树（C++实现）
C++算法题：什么是红黑树？什么是二叉查找树？
feikudai8460的博客
05-10 629
知识体系结构 ¶ 树 树是一种数据结构，它是n(n>=0)个节点的有限集。n=0时称为空树。n>0时，有限集的元素构成一个具有层次感的数据结构。 区别于线性表一对一的元素关系，树中的节点是一对多的关系。树具有以下特点: n>0时，根节点是唯一的，不可能存在多个根节点。 每个节点有零个至多个子节点；除了根节点外，每个节点有且仅有一个父节点。根节点没有父节点。 ¶ 树的遍历 按照根节点访问的顺序不同，树的遍历分为以下三种：前序遍历，中序遍历，后序...
用c++实现红黑树的判断、插入、遍历操作
岩枭的博客
07-26 4870
红黑树        红黑树是一棵二叉搜索树，它在每个节点上增加了一个存储位来表示节点的颜色，可以是Red或Black。通过对任何一条从根到叶子简单路径上的颜色来约束，红黑树保证最长路径不超过最短路径的两倍，因而近似于平衡。 红黑树是满足下面红黑性质的二叉搜索树： 1. 每个节点，不是红色就是黑色的； 2. 根节点是黑色的； 3. 如果一个节点是红色的，则它的两个子节点是黑色的；
一步一步从二叉查找树学到红黑树
承续缘的信仰
08-09 5251
平衡是指所有的叶子的高度趋于平衡，更广义的是指在平衡二叉树上所有可能查找的均摊复杂度偏低。几乎所有平衡树的操作都基于树的旋转操作，通过旋转操作可以使得树趋于平衡。AVL树，红黑树，伸展树，Treap树等都是平衡二叉树。
C++实现二叉树的插入、删除、查询、遍历
热门推荐
远走的兔子博客
04-09 4万+
1.二叉树的概念        树是一些节点的集合，节点之间用边链接，节点之间不能有环路。上层的节点称为父节点，下层节点称为子节点。最上层的节点称为根节点。       二叉树是特殊的树。对于每个节点而言，与之直接相连的子节点不能超过两个（可以为0）。左边的子节点称为左子树，右边的子节点称为右子树。如下图就是一颗二叉树： 与树相关的一些概念：          没有任何子节点的节点
二叉树、霍夫曼编码和红黑树的C++实现
xhh22900的博客
08-04 230
主要参考：《数据结构与算法/leetcode/lintcode题解》、《算法导论》 4. 二叉树 参考：《算法导论》 二叉树每个节点有最多两个子树，子树有左右之分，可以实现二叉查找树和二叉堆。二叉树有个规律，如果一颗二叉树的终端节点数为n0n_0n0​，度为2的节点数为n2n_2n2​，则有n0=n2+1n_0=n_2+1n0​=n2​+1。 二叉树的遍历通常有三个步骤：对当前节点进行操作、遍历左边子节点、遍历右边子节点。访问节点的不同顺序形成了不同的遍历方式。树的遍历通常是用递归的思想来理解和实现的。 遍
构建树的存储结构算法详解：从二叉树到树的类型与遍历
遍历二叉树的方法也被详细阐述，包括前序、中序和后序遍历，这些都是处理和访问树中节点的重要手段。 线索二叉树是一种特殊类型的二叉树，通过在节点中添加额外的信息（线索）来辅助遍历过程，提高某些特定情况下的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值