查找——树表之二叉排序树

在前面已经介绍过了线性表的查找方法：

​​​​​查找的基本概​​​​​​念，线性表的顺序查找

线性表的折半查找与分块查找

这篇文章就介绍一下关于树表的查找方法，我们知道，当表插入、删除操作频繁时，为维护表的有序性，需要移动表中很多记录。所以改用动态查找表——几种特殊的树，我们主要介绍二叉排序树与平衡二叉树。

二叉排序树(Binary Sort Tree)又称为二叉搜索树、二叉查找树。二叉排序树或是空树，或是满足如下性质的二叉树：

若其左子树非空，则左子树上所有结点的值均小于根结点的值；

若其右子树非空，则右子树上所有结点的值均大于等于根结点的值；

其左右子树本身又各是一棵二叉排序树。

二叉排序树的操作——查找

若查找的关键字等于根结点，成功

否则

　   若小于根结点，查其左子树

　   若大于根结点，查其右子树

在左右子树上的操作类似

二叉排序树的存储结构

 如何编写二叉排序树的查找算法?

 我们需要知道：

（1）若二叉排序树为空，则查找失败，返回空指针。

（2）若二叉排序树非空，将给定值key与根结点的关键字T->data.key进行比较：

        若key等于T->data.key，则查找成功，返回根结点地址；

        若key小于T->data.key，则进一步查找左子树；

        若key大于T->data.key，则进一步查找右子树。

因此我们可以写查找算法的递归过程

BSTree SearchBST(BSTree T,KeyType key) 
{
   if((!T) || key==T->data.key) return T;       	 
   else if (key<T->data.key)  return SearchBST(T->lchild,key);	//在左子树中继续查找
   else return SearchBST(T->rchild,key);    		   		//在右子树中继续查找
} // SearchBST

查找算法的性能分析:

 平均查找长度和二叉树的形态有关，即

最好：log2n（形态匀称，与二分查找的判定树相似）

最坏:  （n+1)/2（单支树）

二叉排序树的操作——插入 

例如：

1. 

若二叉排序树为空，则插入结点应为根结点

否则，继续在其左、右子树上查找

        树中已有，不再插入

        树中没有，查找直至某个叶子结点的左子树或右子树为空为止，则插入结点应为该叶子结点的左孩子或右孩子

插入的元素一定在叶结点上。

二叉排序树的操作——生成

从空树出发，经过一系列的查找、插入操作之后，可生成一棵二叉排序树 。

如 {10， 18， 3， 8， 12， 2， 7}

 

  一个无序序列可通过构造二叉排序树而变成一个有序序列。构造树的过程就是对无序序列进行排序的过程。插入的结点均为叶子结点，故无需移动其他结点。相当于在有序序列上插入记录而无需移动其他记录。

 下面是一个不同插入次序的序列生成不同形态的二叉排序树的例子：

 二叉排序树的操作——删除

1. 

删除叶结点，只需将其双亲结点指向它的指针清零，再释放它即可。

被删结点缺右子树，可以拿它的左子女结点顶替它的位置，再释放它。

被删结点缺左子树，可以拿它的右子女结点顶替它的位置，再释放它。

被删结点左、右子树都存在，可以在它的右子树中寻找中序下的第一个结点(关键字最小)，用它的值填补到被删结点中，再来处理这个结点的删除问题（或在它的左子树中寻找中序下的前驱结点（关键字最大））。

下面是一些其他例子：

 下面是一段完整的二叉排序树生成，查找，插入，删除的代码：

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

// 定义二叉树节点结构体
typedef struct Node {
    int data; // 节点存储的数据
    struct Node *left; // 左子节点指针
    struct Node *right; // 右子节点指针
} Node;

// 创建一个新的节点
Node* createNode(int data) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    newNode->data = data;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// 向二叉搜索树中插入一个节点
Node* insert(Node *root, int data) {
    if (root == NULL) {
        return createNode(data);
    }
    if (data < root->data) {
        root->left = insert(root->left, data);
    } else if (data > root->data) {
        root->right = insert(root->right, data);
    }
    return root;
}

// 在二叉搜索树中查找一个节点
Node* search(Node *root, int data) {
    if (root == NULL || root->data == data) {
        return root;
    }
    if (data < root->data) {
        return search(root->left, data);
    } else {
        return search(root->right, data);
    }
}

// 找到以给定节点为根的子树中的最小值节点
Node* findMinValueNode(Node *node) {
    Node *current = node;
    while (current && current->left != NULL) {
        current = current->left;
    }
    return current;
}

// 从二叉搜索树中删除一个节点
Node* deleteNode(Node *root, int data) {
    if (root == NULL) {
        return root;
    }
    if (data < root->data) {
        root->left = deleteNode(root->left, data);
    } else if (data > root->data) {
        root->right = deleteNode(root->right, data);
    } else {
        if (root->left == NULL) {
            Node *temp = root->right;
            free(root);
            return temp;
        } else if (root->right == NULL) {
            Node *temp = root->left;
            free(root);
            return temp;
        }
        Node *temp = findMinValueNode(root->right);
        root->data = temp->data;
        root->right = deleteNode(root->right, temp->data);
    }
    return root;
}

// 中序遍历二叉树并打印节点数据
void inorderTraversal(Node *root) {
    if (root != NULL) {
        inorderTraversal(root->left);
        printf("%d ", root->data);
        inorderTraversal(root->right);
    }
}

int main() {
    Node *root = NULL;
    root = insert(root, 50);
    insert(root, 30);
    insert(root, 20);
    insert(root, 40);
    insert(root, 70);
    insert(root, 60);
    insert(root, 80);

    printf("Inorder traversal of the given tree: ");
    inorderTraversal(root);
	printf("\n");

    printf("Searching for 40: ");
    Node *result = search(root, 40);
    if (result != NULL) {
        printf("Found!");
    } else {
        printf("Not found!");
    }

    printf("Deleting 20: ");
    root = deleteNode(root, 20);
    printf("Inorder traversal after deletion: ");
    inorderTraversal(root);
    printf("\n");

    return 0;
}