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

目录

    • 5.5.3二叉排序树(BST)(后边的排序会详细说明)
      • 1. 二叉排序树的定义
      • 2. 查找操作
      • 3. 插入操作
      • 4. 二叉排序树的构造
    • 数据结构:二叉排序树(Binary Search Tree)
      • 二叉排序树的特性
      • 二叉排序树的结构
      • 二叉排序树的操作
        • 插入操作
        • 查找操作
        • 删除操作
      • 二叉排序树的应用
      • 二叉排序树的数据处理
      • 二叉排序树的时间复杂度
      • 二叉排序树的空间复杂度
      • 总结

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++;
   }
}


24考研数据结构-二叉排序树_第1张图片

数据结构:二叉排序树(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)。使用二叉排序树前,应确保数据的有序性以保证最优的性能。在实际应用中,我们可以根据具体需求选择合适的数据结构,以提高程序的效率和性能。

你可能感兴趣的:(#,数据结构,408,数据结构,考研,算法,笔记,学习)