数据结构—动态查找

动态查找介绍

1. 动态查找的引入：当查找表以线性表的形式组织时，若对查找表进行插入、删除或排序操作，就必须移动大量的记录，当记录数很多时，这种移动的代价很大。

2. 动态查找表的设计思想：表结构本身是在查找过程中动态生成的

若表中存在其关键字等于给定值key的记录,表明查找成功；否则插入关键字等于key的记录。

利用树的形式组织查找表，可以对查找表进行动态高效的查找。

二叉排序树

1. 动态查找表的典型数据结构是二叉排序树，又称二叉查找树，其中序遍历输出为有序序列

二叉排序树是空树或者是具有如下特性的二叉树：

若它的左子树不空，则左子树上所有结点的值均小于根结点的值

若它的右子树不空，则右子树上所有结点的值均大于根结点的值

它的左、右子树也都分别是二叉排序树。

2. 二叉排序树的查找

给定值与根结点比较：

①.若相等，查找成功

②.若小于，查找左子树

③.若大于，查找右子树

实现代码

BSTNode *BST_Serach(BSTNode *T , KeyType key)
{  if (T==NULL)  return(NULL) ;
   else 
   {  if  (EQ(T->key, key) ) 
	   return(T) ;
      else if ( LT(key, T->key) )
        	   return(BST_Serach(T->Lchild, key)) ;
      else  
	   return(BST_Serach(T->Rchild, key)) ;
    }
}

3. 二叉排序树的插入

二叉排序树是一种动态树表

当树中不存在查找的结点时，作插入操作

新插入的结点一定是叶子结点，只需改动一个结点的指针

该叶子结点是查找不成功时路径上访问的最后一个结点左孩子或右孩子(新结点值小于或大于该结点值)

实现代码

void  Insert_BST (BSTNode *T , KeyType  key)
{ BSTNode *x ;
  x=(BSTNode *)malloc(sizeof(BSTNode)) ;
  x->key=key; 
  x->Lchild=x->Rchild=NULL ; 
  if (T==NULL)  
     T=x ;
  else
  {  if (EQ(T->key, x->key) )     return  ;/*  已有结点  */
     else if (LT(x->key, T->key) )
         Insert_BST(T->Lchild, key) ;
     else   
         Insert_BST(T->Rchild, key) ;   
  }
}

4. 性能分析

在最好的情况下，二叉排序树为一近似完全二叉树时，其查找深度为log2n量级，即其时间复杂性为O(log2n)

在最坏的情况下，二叉排序树为近似线性表时(如以升序或降序输入结点时)，其查找深度为n量级，即其时间复杂性为O(n)

5. 其他

一个无序序列可以通过构造一棵二叉排序树而变成一个有序序列（通过中序遍历）

插入新记录时，只需改变一个结点的指针，相当于在有序序列中插入一个记录而不需要移动其它记录

二叉排序树既拥有类似于折半查找的特性O(log2n)，又采用了链表作存储结构

当插入记录的次序不当时(如升序或降序)，则二叉排序树深度很深O(n)，增加了查找的时间

6. 实现代码

#include<iostream>

using namespace std;

class node {
public:
    int data;
    node *left, *right;

    node(int value) {
        data = value;
        left = right = nullptr;
    }
};

class bitree {
private:
    bool flag = false;
    int l;
    node *root;
public:
    bitree() {
        cin >> l;
        root = nullptr;
        for (int i = 0; i < l; i++) {
            int tmp;
            cin >> tmp;
            root = insert(root, tmp);
        }
        pre_order(root);
        cout << endl;
    }

    //二叉树的创建和插入
    node *insert(node *q, int t) {
        if (q == nullptr) {
            q = new node(t);
            return q;
        }
        if (q->data <= t)
            q->right = insert(q->right, t);
        else
            q->left = insert(q->left, t);
        return q;
    }

    //独立插入
    void insert_More() {
        int t;
        cin >> t;
        while (t--) {
            int tmp;
            cin >> tmp;
            insert(root, tmp);
            pre_order(root);
            cout << endl;
        }
    }

    //二叉排序树之查找
    void search_start() {
        int t;
        cin >> t;
        while (t--) {
            flag = false;
            int tmp;
            cin >> tmp;
            int num = 0;
            search(root, tmp, num);
            if (flag)
                cout << num << endl;
            else
                cout << -1 << endl;
        }
    }

    void search(node *p, int tmp, int &num) {
        if (p == nullptr)
            return;
        num++;
        if (p->data == tmp) {
            flag = true;
            return;
        }
        if (tmp > p->data)
            search(p->right, tmp, num);
        else
            search(p->left, tmp, num);
    }

    //先序遍历
    void pre_order(node *p) {
        if (p == nullptr)
            return;
        pre_order(p->left);
        cout << p->data << " ";
        pre_order(p->right);
    }

};