二叉排序樹和紅黑樹

二叉排序樹（Binary Sort Tree），又稱二叉查找樹（Binary Search Tree），也稱二叉搜索樹。

 

定義：

1. 若左子樹不空，則左子樹上全部結點的值均小於或等於它的根結點的值；
2. 若右子樹不空，則右子樹上全部結點的值均大於或等於它的根結點的值；
3. 左、右子樹也分別爲二叉排序樹；

 

添加刪除查找節點方法實現：

#include <stdio.h>  
#include <stdlib.h>  
  
#define SIZE 10  
  
typedef struct tagNode{  
        int value;  
        struct tagNode* left;  
        struct tagNode* right;  
}treeNode;  
  
//打印數組  
void displayArray(int array[],int size){  
        printf("the array is:");  
        int i;  
        for(i=0;i<size;i++){  
                printf("%d ",array[i]);  
        }  
        printf("\n");  
}  
  
//按左中右順序遍歷樹  
void displayTree(treeNode* node){  
        if(node == NULL) return;  
  
        if(node->left != NULL){  
                displayTree(node->left);  
        }  
  
        printf("%d ",node->value);  
  
        if(node->right != NULL){  
                displayTree(node->right);  
        }  
}  
  
//查找以node爲節點的樹中上是否存在vlaue的節點  
treeNode* searchTree(treeNode* node, int value){  
        if(node->value == value){  
                return node;  
        }else if(node->value > value){  
                if(node->left != NULL){  
                        return searchTree(node->left, value);  
                }else{  
                        return NULL;  
                }  
        }else{  
                if(node->right != NULL){  
                        return searchTree(node->right, value);  
                }else{  
                        return NULL;  
                }  
        }  
}  
  
//查找以node爲節點的樹中上是否存在vlaue的節點,parent爲查找到的節點的父節點。  
//dir爲1表示parent節點的左節點爲查找結果  
//dir爲2表示parent節點的右節點爲查找結果  
treeNode* searchTreeWithParent(treeNode* node, treeNode** parent, int* dir, int value){  
        if(node->value == value){  
                return node;  
        }else if(node->value > value){  
                if(node->left != NULL){  
                        *dir = 1;  
                        *parent = node;  
                        return searchTreeWithParent(node->left, parent, dir, value);  
                }else{  
                        return NULL;  
                }  
        }else{  
                if(node->right != NULL){  
                        *dir = 2;  
                        *parent = node;  
                        return searchTreeWithParent(node->right, parent, dir, value);  
                }else{  
                        return NULL;  
                }  
        }  
}  
  
//將iNode插入到以node爲根節點的樹中  
void insertNode(treeNode* node, treeNode* iNode){  
        if(iNode->value >= node->value && node->right != NULL){  
                insertNode(node->right, iNode);  
                return;  
        }  
  
        if(iNode->value < node->value && node->left != NULL){  
                insertNode(node->left, iNode);  
                return;  
        }  
  
        if(iNode->value >= node->value && node->right == NULL){  
                node->right = iNode;  
        }  
  
        if(iNode->value < node->value && node->left == NULL){  
                node->left = iNode;  
        }  
}  
  
//從以root爲根節點的樹中刪除值爲value的節點  
void deleteNode(treeNode** root, int value){  
        treeNode* parent = NULL;  
        int dir = -1;  
        treeNode* deleteNode = searchTreeWithParent(*root,&parent,&dir,value);  
        if(deleteNode == NULL){  
                printf("%s\n", "node not found");  
        }else{  
                if(deleteNode->left == NULL && deleteNode->right == NULL){  
            //對應說明中的a  
                        if(parent != NULL){  
                                if(dir == 1)  
                                        parent->left = NULL;  
                                else  
                                        parent->right = NULL;  
                        }else{//對應說明中的b  
                                *root = NULL;  
                        }  
                }else if(deleteNode->left != NULL && deleteNode->right == NULL){  
                        //對應說明中的c  
            if(parent != NULL){  
                                if(dir == 1)  
                                        parent->left = deleteNode->left;  
                                else  
                                        parent->right = deleteNode->left;  
                        }else{//對應說明中的d  
                                *root = deleteNode->left;  
                        }  
                }else if(deleteNode->left == NULL && deleteNode->right != NULL){  
                        //對應說明中的e  
            if(parent != NULL){  
                                if(dir == 1)  
                                        parent->left = deleteNode->right;  
                                else  
                                        parent->right = deleteNode->right;  
                        }else{//對應說明中的f  
                                *root = deleteNode->right;  
                        }  
                }else{  
                        insertNode(deleteNode->left,deleteNode->right);  
                        //對應說明中的g  
            if(parent != NULL){  
                                if(dir == 1)  
                                        parent->left = deleteNode->left;  
                                else  
                                        parent->right = deleteNode->left;  
                        }else{//對應說明中的h  
                                *root = deleteNode->left;  
                        }  
                }  
                free(deleteNode);  
                deleteNode = NULL;  
        }  
}  
  
//使用array數組中的數，建立以root爲根節點的樹，  
void createTree(treeNode** root, int array[], int size){  
        int i;  
  
        *root = (treeNode*)malloc(sizeof(treeNode));  
        (*root)->value = array[0];  
        (*root)->left = NULL;  
        (*root)->right = NULL;  
  
        for(i=1;i<size;i++){  
                treeNode* child = (treeNode*)malloc(sizeof(treeNode));  
                child->value = array[i];  
                child->left = NULL;  
                child->right = NULL;  
                insertNode(*root, child);  
        }  
}  
  
//刪除以node爲根節點的樹  
void deleteTree(treeNode* node){  
        if(node == NULL) return;  
  
        if(node->left != NULL){  
                deleteTree(node->left);  
        }  
  
        if(node->right != NULL){  
                deleteTree(node->right);  
        }  
  
        if(node->left == NULL && node->right == NULL){  
                free(node);  
                node = NULL;  
        }  
}  
  
int main(int argc, char* argv[]){  
  
        int array[SIZE] = {4,1,45,78,345,23,12,3,6,21};  
        displayArray(array,SIZE);  
  
        treeNode *root = NULL;  
  
        createTree(&root, array, SIZE);  
  
        printf("the tree is(left->middle->right):");  
        displayTree(root);  
        printf("\n");  
  
        int value = atoi(argv[1]);  
        treeNode* parent = NULL;  
        int dir = -1;  
        printf("search value %d:",value);  
        if(searchTree(root,value) != NULL){  
                printf("%s\n","exist");  
        }else{  
                printf("%s\n","not exist");  
        }  
  
        printf("delete value:%d ",value);  
        deleteNode(&root,value);  
        printf("\n");  
        printf("the tree is(left->middle->right):");  
        displayTree(root);  
        printf("\n");  
  
        deleteTree(root);  
        return 0;  
}  

 

紅黑樹是對二叉排序樹的優化，在每次插入節點後根據黑樹樹的特定規則調整樹的結構，使樹儘可能的平衡。

紅黑樹規則：

1. 節點是紅色或黑色
2. 根節點是黑色
3. 每一個葉節點是黑色
4. 每一個紅色節點的兩個子節點是黑色。（從每一個葉子到根的全部路徑上不能由兩個連續的紅色節點）
5. 從任一一個節點到其餘每一個葉子的因此體驗路徑都包含相同數目的黑色節點

 

這些約束強制了紅黑樹的關鍵性質：從根到葉子的最長的可能路徑很少餘最短可能路徑的兩倍長。結果是這個樹大體上是平衡的。由於操做好比插入、刪除和查找某個值的最壞狀況時間都要求與樹的高度成比例，這個在高度上的理論上限容許紅黑樹在最壞狀況下都是高效的，而不一樣於普通的二叉查找樹。

 

要知道爲何這些特性確保了這個結果，注意到性質4致使了路徑不能有兩個毗連的紅色節點就足夠了。最短的可能路徑都是黑色節點，最長的可能路徑有交替的紅色和黑色節點。由於根據性質5全部最長的路徑都有相同數目的黑色節點，這就代表了沒有路徑能多於任何其餘路徑的兩倍長。