2. 程式人生 > >紅黑樹的構建以及插入和刪除操作（C語言完整）

紅黑樹的構建以及插入和刪除操作（C語言完整）

阿新 • • 發佈：2019-01-08

參照演算法導論虛擬碼。
註釋沒有很詳細，建議先看演算法導論或者其他博主的分析搞清楚insert和delete操作的方法。

#include<stdio.h>
#include<stdlib.h>
typedef int type;
typedef enum Color   //定義紅黑樹結點顏色顏色型別  
{
	red = 0,
	black = 1
}Color;
typedef struct rbtree     //定義紅黑樹的結構
{
	Color color;
	type key;
	struct rbtree *left;
	struct rbtree *right;
 

	struct rbtree *parent;

}node, *tree;

node *nil = NULL;                        //建立一個哨兵結點。這裡要用哨兵去讓空的葉子結點的顏色是black的，參照紅黑樹的定義

node* create(type key, node *left, node *right, node *parent)                       //建立結點
{
	node *p;
	p = (node*)malloc(sizeof(node));
	p->color = black;                                                        //預設顏色為black
 

	p->left = left;
	p->right = right;
	p->parent = parent;
	p->key = key;
	/*	printf("創造結點完畢");*/
	return p;

}

void left_rotate(tree &t, node *x)                                 //左旋，這個看圖就能理解具體操作
{
	node *y = x->right;
	x->right = y->left;
	if (y->left != nil)
		y->left->
 
parent = x;
	y->parent = x->parent;
	if (x->parent == nil)
		t = y;
	else
	{
		if (x == x->parent->left)
			x->parent->left = y;
		else
			x->parent->right = y;
	}
	y->left = x;
	x->parent = y;

}

void right_rotate(tree &t, node *x)                   //右旋
{
	node *y = x->left;
	x->left = y->right;
	if (y->right != nil)
		y->right->parent = x;
	y->parent = x->parent;
	if (x->parent == nil)
		t = y;                             //
	else
	{
		if (x == x->parent->left)
			x->parent->left = y;
		else
			x->parent->right = y;
	}
	y->right = x;
	x->parent = y;
}


node* search(tree &t, type key)                        //查詢元素
{
	node *x = t;
	if (x == nil || x->key == key)
	{

		return t;
	}

	if (key < x->key)
	{
		
		return search(x->left, key);
	}
	else

	{
	
		return search(x->right, key);

	}


}                                                                  //遞迴查詢

void rb_insert_fixup(tree &t, node* z)
{
	node *y;
	while ((z->parent != nil) && (z->parent->color == red))                                //only when z's parent is red there will probably obey the red node has two black nodes
	{
		if (z->parent == z->parent->parent->left)                //z'parent is the left node
		{

			y = z->parent->parent->right;                         //let y be z's uncle node
			if (y->color == red)                                  //parent and uncle and itself are all red
			{
				z->parent->color = black;
				y->color = black;
				z->parent->parent->color = red;
				z = z->parent->parent;                              //let z up to its grandpa
			}
			else
			{
				if (z == z->parent->right)                         // z is a right node
				{
					z = z->parent;
					left_rotate(t, z);

				}
				z->parent->color = black;
				z->parent->parent->color = red;
				right_rotate(t, z->parent->parent);
			}

		}
		else                                                     //z's parent is the right node
		{
			y = z->parent->parent->left;
			if (y->color == red)
			{

				z->parent->color = black;
				y->color = black;
				z->parent->parent->color = red;
				z = z->parent->parent;
			}

			else
			{
	            if (z == z->parent->left)                         // z is a left node
				{
					z = z->parent;
					right_rotate(t, z);
				}
				z->parent->color = black;
				z->parent->parent->color = red;
				left_rotate(t, z->parent->parent);
			}
		}

	}

	t->color = black;                                   //始終保持根節點是黑色
}


node* rb_insert(tree &t, node *z)                        //插入操作
{
	if (t == NULL)                                                  //t是空的樹
	{
		t = (tree)malloc(sizeof(node));
		nil = (node*)malloc(sizeof(node));                       //初始化哨兵結點
		nil->color = black;          
		t->left = nil;
		t->right = nil;
		t->parent = nil;
		t->key = z->key;
		t->color = black;         
	}

	else
	{
		node *y = nil;
		node *x = t;                             //


		while (x != nil)
		{
			y = x;
			if (z->key < x->key)
				x = x->left;
			else
				x = x->right;

		}
		z->parent = y;
		if (y == nil)
			t = z;                                  
		else
		{
			if (z->key < y->key)
				y->left = z;
			else
				y->right = z;
		}
		z->left = nil;
		z->right = nil;
		z->color = red;                                     //始終保持插入的結點是紅色，不符合具體性質了再用fixup調整
		rb_insert_fixup(t, z);
	}
	return t;
}
node* rb_insert_(tree &t, type k)                  
{
	node *z;
	z = create(k, NULL, NULL, NULL);
	return  rb_insert(t, z);
}


node* min(tree &m)                     //最小值
{

	node *n = m;

	if (n == nil)
		return nil;

	while (n->left != nil)
	{
		n = n->left;
	}
	return n;
}

node* successor(node *s)           //後繼
{
	node *p;
	if (s->right != nil)             //結點右子樹非空
	{
		return  min(s->right);
	}
	else
	{
		 p = s->parent;                //結點是左孩子，後繼就是他的父節點
		while (p != nil && p->right == s)
		{                                       //結點是右孩子，向上查詢，直到遇到一個有左孩子的父節點，那就是後繼
			{
				s = p;
				p = p->parent;
			}
		}
		return p;
	}
	
}



void rb_delete_fixup(tree &t, node *x)
{
	node *w;
	while (x != t && x->color == black)                      //
	{
		if (x == x->parent->left)
		{
			w = x->parent->right;
			if (w->color == red)
			{
				w->color = black;
				x->parent->color = red;
				left_rotate(t, x->parent);
				w = x->parent->right;
			}
			if (w->left->color == black && w->right->color == black)
			{
				w->color = red;
				x = x->parent;
			}
			else if (w->right->color == black)
			{
				w->left->color = black;
				w->color = red;
				right_rotate(t, w);
				w = x->parent->right;
			}
			w->color = x->parent->color;
			x->parent->color = black;
			w->right->color = black;
			left_rotate(t, x->parent);
			x = t;                                        //

		}
		else
		{
			w = x->parent->left;
			if (w->color = red)
			{
				w->color = black;
				x->parent->color = red;
				right_rotate(t, x->parent);
				w = x->parent->left;
			}
			if (w->left->color == black && w->right->color == black)
			{
				w->color = red;
				x = x->parent;
			}
			else if (w->left->color == black)
			{
				w->right->color = black;
				w->color = red;
				left_rotate(t, w);
				w = x->parent->right;
			}
			w->color = x->parent->color;
			x->parent->color = black;
			w->left->color= black;
			right_rotate(t, x->parent);
			x = t;                                            //

		}
	}
	x->color = black;
}

node* rb_delete(tree &t, node *z)
{
node *y, *x;
    node *m=nil;
	node* n = z;
	if (z->left == nil || z->right == nil)
		y = z;
	else
		y = successor(n);                                  //這一行使z的右孩子發生變化
	if (y->left != nil)
		x = y->left;
	else
		x = y->right;
	x->parent = y->parent;
	if (y->parent == nil)
		t = x;                            //
	else
	{
		if (y == y->parent->left)
			y->parent->left = x;
		else
			y->parent->right = x;
	}
	if (y != z)
	{
		z->key = (y->key);
		
	}
	if (y->color == black)
		rb_delete_fixup(t, x);
	return t;
}

node* rb_delete_(tree &t, type k)
{
	node *z;
	z = search(t, k);

	if (z != nil)
	{
		t = rb_delete(t, z);
	}
	else
		printf("無此元素");
	return t;
}


void print_tree(tree &t)                        //中序遍歷列印
{
	if (t != nil && t != NULL)
	{
		print_tree(t->left);
		printf("%7d ,   %5d\n ", t->key, t->color);
		print_tree(t->right);
	}
}

int main()
{
	int i;
	tree zz = NULL, mm = NULL, nn = NULL, xx = NULL, yy = NULL;
	type k;
	int a[12] = {3,12,15,17,19,55,20,18,36,48,31,29 };
	printf("\n原來的數字是：----------------------------------------\n");
	for (i = 0; i<12; i++)
	{
		printf("%d  ", a[i]);
		zz = rb_insert_(zz, a[i]);
	}

	printf("\n中序遍歷是：-------------------------------------------\n");
	printf("規定：red=0,black=1\n");
	print_tree(zz);
	printf("\n要刪除的值是：---------------------------------------");
	scanf_s("%d", &k);
	yy = rb_delete_(zz, k);
	print_tree(yy);
	printf("\n要插入的值是：--------------------------------------");
	scanf_s("%d", &k);
	rb_insert_(zz, k);
	print_tree(zz);
}

過程中遇到的問題：
1.開始不知道有列舉型別，不知道怎麼定義color，用了#define結果總是報錯
2.開始沒有使用哨兵元素，會導致在逐漸插入的過程中，檢驗父節點，祖父節點或叔叔結點可能碰到空的時候那個NULL是沒有顏色的，執行到這裡就中斷了。所以必須事先定義好哨兵nil。
3.演算法導論上的虛擬碼結構不算清晰，就是if else 那些巢狀寫的不太清楚，得理清楚邏輯結構了才能自己寫對。
4.導論上的地方省略了結構相似的部分，x == x->parent->left,->right就省略了，看起來不需要動腦子，其實還是容易寫錯的
5.學習方式應該是有問題的，先看的演算法導論，把思路理得清楚一些了，然後看的網上的解析更明白一些了，但是還是體現在被動的去看懂。然後再去根據導論的虛擬碼實現，結果又很多bug，改了一些，然後又找了紅黑樹的現成程式碼參照修改，把它改出來了。但是這樣學習感覺還是很被動的再接受，從翻譯虛擬碼到debug，其實進步並不大，現在要自己不參照虛擬碼寫出來還是不行。甚至不看書複述紅黑樹的基本思想也不能完整想出來。所以這樣是有很多問題的，今後要改進。。。

相關推薦

紅黑樹的構建以及插入和刪除操作（C語言完整）

參照演算法導論虛擬碼。 註釋沒有很詳細，建議先看演算法導論或者其他博主的分析搞清楚insert和delete操作的方法。 #include<stdio.h> #include<stdlib.h> typedef int type; typ

二叉樹之紅黑樹的實現-插入和刪除(三)

  #include <stdio.h>   #include <stdlib.h>

MyBatis一對多的左連線查詢、分步查詢以及插入和刪除操作

例如有兩張表，分別是客戶表和訂單表，一個客戶有多個訂單，一個訂單屬於一個客戶。 兩個實體類Customer   Order 如下： package com.itlike.domain; import lombok.Getter; import lombok.Setter; imp

紅黑樹Red-Black tree初步詳解（Java程式碼實現）

紅黑樹Red-Blacktree初步詳解 本部落格的參考資料： 演算法導論 http://blog.csdn.net/v_july_v/article/details/6105630 http://www.cnblogs.com/skywang12345/p/3624343

迴圈佇列的插入與刪除操作（C++）

記錄一下C++實現迴圈佇列；#include<iostream> using namespace std; class queue { public: queue(int max) {

樹的三種遍歷方式（C語言實現）

//************************************************************************* // 【前序】遍歷演算法 //二叉樹不空，先訪問根結點，然後前序遍歷左子樹，再前序遍歷右子樹 //***********************

紅黑樹的添加與刪除

tps 根節點 位置 runjs insert cas 高度 spl 結點 主脈絡參考http://www.cnblogs.com/skywang12345/p/3245399.html#!comments 補圖刪除操作：https://blog.csdn.net/eson

紅黑樹——以無厚入有間（插入）

常數 特殊 節點和 oid 出了 復雜度 pan 紅黑樹規則 http 首先說一下，關於紅黑樹有一篇很棒的論文《A dichromatic framework for balanced trees》，作者之一的Robert Sedgewick，想必大家不會陌生。如果有興趣可

紅黑樹的左旋和又旋

今天先來用java實現紅黑色左旋和右旋。後邊再把新增、刪除給補充上。 什麼是紅黑樹？ 紅黑樹是一種近似平衡的二叉查詢樹，它能夠確保任何一個節點的左右子樹的高度差不會超過二者中較低那個的一陪。具體來說，紅黑樹是滿足如下條件的二叉查詢樹（binary search tree）： 每個節

圖解B樹和B+樹的插入和刪除操作

一，    M階B+樹的定義(M階是指一個節點最多能擁有的孩子數,M>2):圖1.1 3階B+樹        (1)根結點只有1個，分支數量範圍[2,m]。        (2)除根以外的非葉子結點，每個結點包含分支數範圍[[m/2],m]，其中[m/2]表示取大於m/2的最小整數。        (

b+樹的插入和刪除操作

轉載自：b+樹介紹B+樹B+樹和二叉樹、平衡二叉樹一樣，都是經典的資料結構。B+樹由B樹和索引順序訪問方法（ISAM，是不是很熟悉？對，這也是MyISAM引擎最初參考的資料結構）演化而來，但是在實際使用過程中幾乎已經沒有使用B樹的情況了。B+樹的定義十分複雜，因此只簡要地介紹

資料結構——樹（8）——二叉搜尋樹的插入和刪除操作

二叉搜尋樹的插入操作 我們要在二叉搜尋樹中執行各種操作的前提就是，我們首先要有一棵二叉搜尋樹。那麼，如何建立一棵二叉搜尋樹呢？最簡單的方法就是我們可以從一棵空樹開始，每次呼叫一個addNode函式，將一個新的值插入二叉搜尋樹中。但是在每次插入的時候我們都要保持

平衡二叉樹(AVL)的插入和刪除詳解(上)

在電腦科學中，AVL樹是最先發明的自平衡二叉查詢樹。在AVL樹中任何節點的兩個子樹的高度最大差別為1，所以它也被稱為高度平衡樹。查詢、插入和刪除在平均和最壞情況下都是O（log n）。增加和刪除可能需要通過一次或多次樹旋轉來重新平衡這個樹。AVL樹得名於它的發明者G.M.

紅黑樹(一)之 原理和演算法詳細介紹

概要      作者：Sky Wang    於 2013-08-08                                概述：R-B Tree，又稱為“紅黑樹”。本文參考了《演算法導論》中紅黑樹相關知識，加之自己的理解，然後以圖文的形式對紅黑樹進行說明。本文的主要內容包括：紅黑樹

二叉樹插入和刪除操作的遞迴實現（c語言）

連結串列和陣列是最常見的資料結構，對於資料結構來說，查詢（Find），最大最小值（FindMin，FindMax），插入（Insert）和刪除（Delete）操作是最基本的操作。對於連結串列和陣列來說，這些操作的時間界為O（N），其中N為元素的個數。陣列的插入和刪除需要對其他

資料結構 — 淺析紅黑樹原理以及實現

淺析紅黑樹原理以及實現我們在上一篇部落格認識到了平衡二叉樹(AVLTree)，瞭解到平衡二叉樹的性質，其實平衡二叉樹最大的作用就是查詢,AVL樹的查詢、插入和刪除在平均和最壞情況下都是O(logn)。AVL樹的效率就是高在這個地方。如果在AVL樹中插入或刪除節點後，使得高度之

8.紅黑樹的定義，紅黑樹的效能分析和與平衡二叉樹的比較

平衡二叉樹 平衡二叉樹或者是一顆空的二叉排序樹，或是具有下列性質的二叉排序樹： 根節點的左子樹和右子樹的深度最多相差1根節點的左子樹和右子樹都是平衡二叉樹 平衡因子 平衡因子是該節點的左子樹的深度與右子樹的深度之差。 最小不平衡子樹 在平衡二叉樹的構造過程中，以距離插入節

資料結構——紅黑樹的資料插入操作

1. 紅黑樹     1. 紅黑樹是二叉搜尋樹的優化版，應為如果二叉搜尋樹的節點大部分全集中在左子樹或右子

mybatis使用foreach進行批量插入和刪除操作

JD div foreach class AR tis 默認 post AC 一、批量插入 1.mapper層 int insertBatchRoleUser(@Param("lists") List<RoleUser> lists);//@Param

連結串列的插入和刪除操作詳解（C語言實現+詳解註釋）

連結串列的基本操作中，連結串列結點的插入和刪除相對比較複雜，需根據結點插入位置的不同，使用合理的方法在不破壞原連結串列結構的前提下將其插入到連結串列中。 本節將詳解介紹這兩種操作的具體實現方法，讀者只需牢記實現步驟，即可輕鬆解決這兩大難點。 連結串列中插入結點 連結串列中插入結點，根據插入位置的不同，可