红黑树C++完整版

最新推荐文章于 2024-06-07 23:43:43 发布

薛萌

最新推荐文章于 2024-06-07 23:43:43 发布

阅读量677

点赞数 1

文章标签： C++ 算法红黑树

本文链接：https://blog.csdn.net/vista1995/article/details/52153873

版权

这里写代码片//异常类
///
Except.h
///

#ifndef EXCEPT_H_
#define EXCEPT_H_

#include <string>

using namespace std;

class DSException {

	public:
		DSException(const string &msg = ""):message(msg) {}
		virtual ~DSException() {};
		virtual string toString() const {
			return "Exception " + string(":") + what();
		}
		virtual string what() const {
			return message;
		}
	private:
		string message;

};

class DuplicateItemException : public DSException {

	public:
		DuplicateItemException(const string &msg = ""):DSException(msg) {}

};

class NullPointerException : public DSException {

	public:
		NullPointerException(const string &msg = ""):DSException(msg) {}

}

#endif

//
Wrapper.h
//

#ifndef WRAPPER_H_
#define WRAPPER_H_

#include "Except.h"

template <class Object>
class Cref {

	public:
		Cref():obj(NULL) {}
		explicit Cref(const Object &x) : obj(&x) {}
		Object &get() const {
			if(isNull()) {
				throw NullPointerException();
			} else {
				return *obj;
			}
		}
		bool isNull() const {
			return obj == NULL;
		}
	private:
		Object *obj;
};

#endif

///
RedBlackTree.h 最最核心类
//

#ifndef RED_BLACK_TREE_H_
#define RED_BLACK_TREE_H_

#include "Except.h"
#include "Wrapper.h"
/*
*红黑树规则：
*1.每一个节点不是红色就是黑色
*2.根总是黑色的
*3.如果节点是红色，则他的子节点必须是黑色的
*4.从根到叶节点的每条路径，必须包含相同数目的黑色节点
*/

template <class Comparable>
class RedBlackTree;

template <class Comparable>
class RedBlackNode;

template <class Comparable>
class RedBlackTree {

	public:
		enum {
		    RED,BLACK
		};
		RedBlackTree(const Comparable &negInf);
		~RedBlackTree();
		void insert(const Comparable &x);
		Cref<Comparable> find(const Comparable &x);
		Cref<Comparable> findMin() const;
		Cref<Comparable> findMax() const;
		bool isEmpty() const;
		void makeEmpty();
		typedef RedBlackNode<Comparable> Node;
	private:
		Node *header;
		Node *nullNode;
		//当前节点
		Node *current;
		//当前节点的父节点
		Node *parent;
		//祖父节点
		Node *grand;
		//曾祖父节点
		Node *great;

		void rotateWithLeftChild(Node* &k2) const;
		void rotateWithRightChild(Node* &k1) const;

		void doubleRotateWithLeftChild(Node* &k3) const;
		void doubleRotateWithRightChild(Node* &k1) const;

		void handleReorient(const Comparable &item);
		RedBlackNode<Comparable> *rotate(const Comparable &item,Node *theParent) const;
		void reclaimMemory(Node* t) const;

};

template <class Comparable>
class RedBlackNode {

	private:
		Comparable element;
		RedBlackNode *left;
		RedBlackNode *right;
		int color;
		RedBlackNode(const Comparable &theElement = Comparable(),
		             RedBlackNode *lt = NULL,
		             RedBlackNode *rt = NULL,
		             int c = RedBlackTree<Comparable>::BLACK)
			: element(theElement),left(lt),right(rt),color(c) {}

		friend class RedBlackTree<Comparable>;

};

template <class Comparable>
RedBlackTree<Comparable>::RedBlackTree(const Comparable &negInf) {

	nullNode = new Node();
	nullNode->left = nullNode->right = nullNode;
	header = new Node(negInf);
	header->left = header->right = nullNode;

}

template <class Comparable>
RedBlackTree<Comparable>::~RedBlackTree() {

	delete nullNode;
	delete header;

}

template <class Comparable>
void RedBlackTree<Comparable>::insert(const Comparable &x) {

	current = parent = grand = header;
	nullNode->element = x;
	while(current->element != x) {
		great = grand;
		grand = parent;
		parent = current;
		current = x < current->element ? current->left : current->right;
		//一个节点两个孩子都是红色
		if(current->left->color == RED && current->right->color == RED) {
			handleReorient(x);
		}
	}
	if(current != nullNode) {
		throw DuplicateItemException();
	}
	current = new Node(x,nullNode,nullNode);
	if(x < parent->element) {
		parent->left = current;
	} else {
		parent->right = current;
	}
	handleReorient(x);

}

//带着左孩子向右移动
template <class Comparable>
void RedBlackTree<Comparable>::rotateWithLeftChild(Node* &k2) const {

	Node *k1 = k2->left;
	//横向移动
	k2->left = k1->right;
	//k2下降
	k1->right = k2;
	//k1上升成为根
	k2 = k1;

}

//带着右孩子向左移动
template <class Comparable>
void RedBlackTree<Comparable>::rotateWithRightChild(Node* &k1) const {

	Node *k2 = k1->right;
	//横向移动
	k1->right = k2->left;
	//k1下降
	k2->left = k1;
	//k2上升成为根
	k1 = k2;

}

template <class Comparable>
void RedBlackTree<Comparable>::doubleRotateWithLeftChild(Node* &k3) const {

	rotateWithRightChild(k3->left);
	rotateWithLeftChild(k3);

}

template <class Comparable>
void RedBlackTree<Comparable>::doubleRotateWithRightChild(Node* &k1) const {

	rotateWithLeftChild(k1->right);
	rotateWithRightChild(k1);

}

template <class Comparable>
void RedBlackTree<Comparable>::handleReorient(const Comparable &item) {

	//变色
	//当发现有个节点有两个红色节点的时候，把自身变红，把两个节点变黑
	current->color = RED;
	current->left->color = BLACK;
	current->right->color = BLACK;

	//父节点是红色
	if(parent->color == RED) {
		//将爷爷变为红色
		grand->color = RED;
		//判断是内部孙子还是外部孙子
		/*
		*如果item小于爷爷 且 item小于爸爸 则是左外部孙子
		*如果item大于爷爷 且 item大于爸爸 则是右外部孙子
		*外部孙子做单旋转
		*如果两个条件不同时满足则是内部孙子
		*内部孙子做爽旋转
		*/
		if(item < grand->element != item < parent->element) {
			//内部孙子加多一次旋转
			parent = rotate(item,grand);
		}
		current = rotate(item,great);
		current->color = BLACK;
	}
	header->right->color = BLACK;

}

//通用旋转函数
/*
*theParent是item的父节点，item为被旋转的节点
*旋转可能性：
*左子树像向转，左子树向右转
*右子树像向转，右子树向右转
*/
template <class Comparable>
RedBlackNode<Comparable> * RedBlackTree<Comparable>::rotate(const Comparable &item,Node *theParent) const {

	//比父节点小则在左边,为左子树
	if(item < theParent->element) {
		item < theParent->left->element ?
		//左子树的节点有左孩子，则往右转
		rotateWithLeftChild(theParent->left) :
		//左子树的节点有右孩子，则往左转
		rotateWithRightChild(theParent->left);
		return theParent->left;
	} else {//比父节点小大则在右边,为右子树
		item < theParent->right->element ?
		//右子树的节点有左孩子，则往右转
		rotateWithLeftChild(theParent->right) :
		//右子树的节点有右孩子，则往左转
		rotateWithRightChild(theParent->right);
		return theParent->right;
	}

}

template <class Comparable>
Cref<Comparable> RedBlackTree<Comparable>::find(const Comparable &x) {

	nullNode->element = x;
	Node *curr = header->right;
	for(;;) {
		if(x < curr->element) {
			curr = curr->left;
		} else if(x > curr->element) {
			curr = curr->right;
		} else if(curr != nullNode) {
			return Cref<Comparable>(curr->element);
		} else {
			return Cref<Comparable>();
		}
	}

}

template <class Comparable>
Cref<Comparable> RedBlackTree<Comparable>::findMin() const {

	if(isEmpty()) {
		return Cref<Comparable>();
	}
	Node *itr = header->right;
	while(itr->left != nullNode) {
		itr = itr->left;
	}
	return Cref<Comparable>(itr->element);

}

template <class Comparable>
Cref<Comparable> RedBlackTree<Comparable>::findMax() const {

	if(isEmpty()) {
		return Cref<Comparable>();
	}
	Node *itr = header->right;
	while(itr->left != nullNode) {
		itr = itr->right;
	}
	return Cref<Comparable>(itr->element);

}

template <class Comparable>
bool RedBlackTree<Comparable>::isEmpty() const {

	return header->right == nullNode;

}

template <class Comparable>
void RedBlackTree<Comparable>::makeEmpty() {

	reclaimMemory(header->right);
	header->right = nullNode;

}

template <class Comparable>
void RedBlackTree<Comparable>::reclaimMemory(Node* t) const {

	if(t != t->left) {
		reclaimMemory(t->left);
		reclaimMemory(t->right);
		delete t;
	}

}

#endif

//
main.cpp

#include <iostream>

#include "RedBlackTree.h"

using namespace std;

int main(int argc, char** argv) {

	RedBlackTree<int> t(-99999);
	t.insert(50);
	t.insert(40);
	t.insert(30);

	return 0;

}

薛萌

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
红黑树C++完整版

//异常类 /////////////////////////////////////////////////////////////////////////// Except.h ///////////////////////////////////////////////////////////////////////////ifndef EXCEPT_H_define EXCEPT_H_
复制链接

扫一扫