24考研数据结构-二叉排序树

5.5.3二叉排序树（BST）（后边的排序会详细说明）

1. 二叉排序树的定义

左子树结点值<根结点值<右子树结点值

2. 查找操作

typedef struct BSTNode{
   int key;
   struct BSTNode *lchild, *rchild;
}BSTNode, *BSTree;

//在二叉排序树中查找值为key的结点（非递归）
//最坏空间复杂度：O(1)
BSTNode *BST_Search(BSTree T, int key){
   while(T!=NULL && key!=T->key){        //若树空或等于跟结点值，则结束循环
      if(key<T->key)       //值小于根结点值，在左子树上查找
         T = T->lchild;
      else                  //值大于根结点值，在右子树上查找
         T = T->rchild;
   }
   return T;
}

//在二叉排序树中查找值为key的结点（递归）
//最坏空间复杂度：O(h)
BSTNode *BSTSearch(BSTree T, int key){
   if(T == NULL)
      return NULL;
   if(Kry == T->key)
      return T;
   else if(key < T->key)
      return BSTSearch(T->lchild, key);
   else 
      return BSTSearch(T->rchild, key);
}

3. 插入操作

//在二叉排序树中插入关键字为k的新结点（递归）
//最坏空间复杂度：O(h)
int BST_Insert(BSTree &T, int k){
   if(T==NULL){           //原树为空，新插入的结点为根结点
      T = (BSTree)malloc(sizeof(BSTNode));
      T->key = k;
      T->lchild = T->rchild = NULL;
      return 1;                       //插入成功
   }
   else if(K == T->key)               //树中存在相同关键字的结点，插入失败
      return 0;
   else if(k < T->key)                 
      return BST_Insert(T->lchild,k);
   else 
      return BST_Insert(T->rchild,k);
}

4. 二叉排序树的构造

//按照str[]中的关键字序列建立二叉排序树
void Crear_BST(BSTree &T, int str[], int n){
   T = NULL;                     //初始时T为空树
   int i=0;
   while(i<n){
      BST_Insert(T,str[i]);     //依次将每个关键字插入到二叉排序树中
      i++;
   }
}

数据结构：二叉排序树（Binary Search Tree）

在计算机科学中，二叉排序树（BST）是一种重要的数据结构，它具有良好的查找、插入和删除操作的性能。二叉排序树是一种二叉树，其中每个节点的左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这个特性使得二叉排序树成为一种非常高效的数据结构，特别适用于排序和搜索操作。

二叉排序树的特性

1. 任意节点的左子树中的所有节点的值都小于该节点的值。
2. 任意节点的右子树中的所有节点的值都大于该节点的值。
3. 任意节点的左右子树也分别是二叉排序树。

二叉排序树的结构

二叉排序树的每个节点通常包含三个部分：

• 数据域：用于存储节点所包含的数据。
• 左子节点指针：指向左子树的根节点。
• 右子节点指针：指向右子树的根节点。

class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

二叉排序树的操作

插入操作

插入操作是向二叉排序树中添加一个新节点。要保持二叉排序树的特性，需要按照以下步骤进行插入：

1. 如果树为空，则直接将新节点作为根节点。
2. 否则，从根节点开始，比较新节点的值与当前节点的值大小关系。
3. 如果新节点的值小于当前节点的值，则继续在左子树中插入新节点。
4. 如果新节点的值大于当前节点的值，则继续在右子树中插入新节点。

def insert(root, data):
    if root is None:
        return Node(data)
    if data < root.data:
        root.left = insert(root.left, data)
    elif data > root.data:
        root.right = insert(root.right, data)
    return root

查找操作

查找操作是在二叉排序树中查找一个特定值。从根节点开始，根据当前节点的值与目标值的大小关系，逐步向左子树或右子树进行查找，直到找到目标值或遍历到叶子节点为止。

def search(root, target):
    if root is None or root.data == target:
        return root
    if target < root.data:
        return search(root.left, target)
    return search(root.right, target)

删除操作

删除操作是从二叉排序树中删除一个节点。删除节点的操作相对复杂，需要考虑节点的子节点情况和树的重新平衡。有三种情况需要考虑：

1. 节点是叶子节点：直接删除该节点即可。
2. 节点只有一个子节点：删除节点后，用其子节点代替删除的节点位置。
3. 节点有两个子节点：找到节点的后继节点（即右子树中的最小节点），用后继节点的值替换删除节点的值，并递归删除后继节点。

def delete(root, target):
    if root is None:
        return root
    if target < root.data:
        root.left = delete(root.left, target)
    elif target > root.data:
        root.right = delete(root.right, target)
    else:
        if root.left is None:
            return root.right
        elif root.right is None:
            return root.left
        temp = find_min(root.right)
        root.data = temp.data
        root.right = delete(root.right, temp.data)
    return root

def find_min(root):
    while root.left:
        root = root.left
    return root

二叉排序树的应用

二叉排序树在实际应用中广泛使用，特别适用于以下场景：

• 排序操作：由于二叉排序树的特性，它可以快速对数据进行排序。
• 搜索操作：查找特定值时，二叉排序树的查找操作效率高。
• 范围搜索：二叉排序树可以方便地进行范围搜索，例如查找在某个范围内的节点。

总之，二叉排序树是一种重要的数据结构，在数据的查找、插入和删除操作上具有高效性能和灵活性，因此被广泛应用于各种领域的计算机程序中。

二叉排序树的数据处理

二叉排序树适合处理有序数据，如数字、字母等。当我们需要对大量有序数据进行搜索、插入、删除等操作时，BST能够在时间复杂度为O(log n)的情况下高效地完成。对于非有序数据，BST的性能可能会下降至O(n)，因此在使用BST前应确保数据的有序性。

二叉排序树的时间复杂度

• 查找：平均时间复杂度为O(log n)，最坏情况下为O(n)。
• 插入：平均时间复杂度为O(log n)，最坏情况下为O(n)。
• 删除：平均时间复杂度为O(log n)，最坏情况下为O(n)。

二叉排序树的空间复杂度

二叉排序树的空间复杂度主要取决于树的高度，最坏情况下为O(n)，平均情况下为O(log n)。由于BST是一个动态数据结构，它的空间复杂度可能会随着插入和删除操作的执行而变化。

总结

二叉排序树是一种常见的数据结构，适合处理有序数据，能够高效地进行搜索、插入、删除等操作。它的时间复杂度取决于树的高度，平均情况下为O(log n)，最坏情况下为O(n)。使用二叉排序树前，应确保数据的有序性以保证最优的性能。在实际应用中，我们可以根据具体需求选择合适的数据结构，以提高程序的效率和性能。