搜索算法总结

搜索算法总结

（红黑树没写。。）

参考资料：

《算法导论》

《算法：C语言实现(第1-4部分)》

《大话数据结构》

输出如下：

#include <iostream>
#include <bits/stdc++.h>

#define MaxRandom 100                                // 随机数生成范围
#define LengthOfWaitSort 20                            // 随机数生成个数

using namespace std;


/*******************************************************************/
// 验证输出
void printAfterSort(int* nums, int length)
{
    for (int i = 0; i < length; ++i)
    {
        printf("%4d",nums[i]);
    }
    printf("
");
}
/*******************************************************************/


/*******************************************************************/
// 快速排序
void quick_sort(int* nums, int left, int right)
{
    if (left < right)
    {
        int i = left;
        int j = right;
        int flag = nums[left];

        while (i < j)
        {
            while (i<j && nums[j]>=flag)            // 从右向左找第一个比基数小的元素
            {
                j --;
            }
            if (i < j)
            {
                nums[i++] = nums[j];
            }

            while (i<j && nums[i]<=flag)            // 从左向右找第一个比基数大的元素
            {
                i ++;
            }
            if (i < j)
            {
                nums[j--] = nums[i];
            }
        }

        nums[i] = flag;
        quick_sort( nums, left, i-1 );
        quick_sort( nums, i+1, right);
    }
}

void QuickSort(int* nums, int length)
{
    int left  = 0;
    int right = length - 1;
    quick_sort(nums, left, right);
    // 输出
    printf("
Quick Sort:
");
    printAfterSort(nums, length);
}
/*******************************************************************/



/*******************************************************************/
// 顺序查找
void Sequential_Search(int* nums, int length, int key)
{
    printf("Sequential Search:
");
    for (int i = 0; i < length; ++i)
    {
        if (nums[i] == key)
        {
            printf("Find %d in nums[%d]", key, i);
            return;
        }
    }
    printf("Not Find!
");
}
/*******************************************************************/


/*******************************************************************/
// 哨兵顺序查找
void Sequential_Search2(int* nums, int length, int key)
{
    printf("Sequential Search2:
");
    if (nums[0] == key)
    {
        printf("Find %d in nums[0]", key);
        return;
    }
    int temp = nums[0];
    nums[0] = key;
    int i = length;
    while (nums[i] != key)
    {
        i --;
    }
    if (i == 0)
    {
        printf("Not Find!
");
        nums[0] = temp;
    }
    else
    {
        printf("Find %d in nums[%d]", key, i);
        nums[0] = temp;
        return;
    }
}
/*******************************************************************/


/*******************************************************************/
// 二分查找(有序)
void Binary_Search(int* nums, int length, int key)
{
    printf("Binary Search:
");
    int left, right, middle;
    left  = 0;
    right = length - 1;

    while (left <= right)
    {
        middle = (left + right) / 2;
        if (key < nums[middle])
        {
            right = middle - 1;
        }
        else if (key > nums[middle])
        {
            left = middle + 1;
        }
        else
        {
            printf("Find %d in nums[%d]", key, middle);
            return;
        }
    }
    printf("Not Find!
");
}
/*******************************************************************/


/*******************************************************************/
// 插值查找
void Insert_Search(int* nums, int length, int key)
{
    printf("Insert Search:
");
    int left, right, middle;
    left  = 0;
    right = length - 1;

    while (left <= right)
    {
        middle = left + (right-left)*(key-nums[left])/(nums[right]-nums[left]);
                                                    // 只在middle取值与二分不同
        if (key < nums[middle])
        {
            right = middle - 1;
        }
        else if (key > nums[middle])
        {
            left = middle + 1;
        }
        else
        {
            printf("Find %d in nums[%d]", key, middle);
            return;
        }
    }
    printf("Not Find!
");
}
/*******************************************************************/


/*******************************************************************/
// 斐波那契查找
void Fibonacci_Search(int* nums, int length, int key)
{
    printf("Fibonacci Search:
");
    int Fibonacci[1000];                            // 斐波那契数列
    Fibonacci[0] = 0;
    Fibonacci[1] = 1;
    for (int i = 2; i < 1000; ++i)
    {
        Fibonacci[i] = Fibonacci[i-1] + Fibonacci[i-2];
    }
    int left, right, middle;
    left  = 0;
    right = length - 1;

    int k = 0;
    while (length > Fibonacci[k]-1)                    // 计算n位于斐波那契数列的位置
    {
        ++k;
    }
    int* temp;                                        // 扩展nums到Fibonacci[k]-1的长度
    temp = new int [Fibonacci[k] - 1];
    memcpy(temp, nums, length* sizeof(int));

    for (int i = length; i < Fibonacci[k]-1; ++i)    // 填充剩余部分
    {
        temp[i] = nums[length - 1];
    }

    while (left <= right)
    {
        middle = left + Fibonacci[k-1] - 1;
        if (key < temp[middle])
        {
            right = middle - 1;
            k = k-1;                                // 斐波那契数列下标-1
        }
        else if (key > temp[middle])
        {
            left = middle + 1;
            k = k-2;                                // 斐波那契数列下标-2
        }
        else
        {
            if (middle < length)
            {
                printf("Find %d in nums[%d]", key, middle);
                return;
            }
            else
            {
                printf("Find %d in nums[%d]", key, length-1);
                return;
            }
        }
    }
    delete [] temp;
}
/*******************************************************************/


/*******************************************************************/
// 二叉排序树
typedef struct BitNode                                // 结点结构
{
    int data;
    struct BitNode *lchild;
    struct BitNode *rchild;
} BitNode, *Bitree;

int LevelTraverse(Bitree T)                            // 层序遍历
{
    printf("Level Taverse:
");
    if (T == NULL)
    {
        return 0;
    }
    vector<BitNode *> vec;
    vec.push_back(T);
    int cur = 0;
    int last = 1;

    while (cur < vec.size())
    {
        last = vec.size();
        while (cur < last)
        {
            cout << vec[cur]->data << " ";
            if (vec[cur]->lchild != NULL)
            {
                vec.push_back(vec[cur]->lchild);
            }
            if (vec[cur]->rchild != NULL)
            {
                vec.push_back(vec[cur]->rchild);
            }
            ++ cur;
        }
        cout << endl;
    }
    return 0;
}

int PreOrderTraverse(Bitree T)                        // 前序遍历
{
    if (T == NULL)
    {
//        printf("Not Find!
");
        return 0;
    }
    printf("%4d ", T->data);
    PreOrderTraverse(T->lchild);
    PreOrderTraverse(T->rchild);
    return 0;
}

int InOrderTraverse(Bitree T)                        // 中序遍历
{
    if (T == NULL)
    {
//        printf("Not Find!
");
        return 0;
    }
    InOrderTraverse(T->lchild);
    printf("%4d ", T->data);
    InOrderTraverse(T->rchild);
    return 0;
}

/*
 * 递归查找二叉排序树T中是否存在key,
 * 指针f指向T的双亲，其初始调用值为NULL
 * 若查找成功，则指针p指向该数据元素结点，并返回1
 * 否则指针p指向查找路径上访问的最后一个结点并返回0
 */
int SearchBST(Bitree T, int key, Bitree f, Bitree *p)
{
    if (!T)                                            // 不存在
    {
        *p = f;
        return 0;
    }
    else if (key == T->data)                        // 查找成功
    {
        *p = T;
        return 1;
    }
    else if (key < T->data)
    {
        return SearchBST(T->lchild, key, T, p);        // 在左子树继续查找
    }
    else
    {
        return SearchBST(T->rchild, key, T, p);        // 在右子树继续查找
    }
}

/*
 * 二叉排序树中不存在key的时候,
 * 插入key返回1，否则返回0
 */
int InsertBST(Bitree *T, int key)
{
    Bitree p, s;
    if (!SearchBST(*T, key, NULL, &p))                // 没查到key
    {
        s = (Bitree)malloc(sizeof(BitNode));
        s->data = key;
        s->lchild = s->rchild = NULL;
        if (!p)
        {
            *T = s;                                    // 插入s为新的根结点
        }
        else if (key < p->data)
        {
            p->lchild = s;                            // 插入s为p的左孩子
        }
        else
        {
            p->rchild = s;                            // 插入s为p的右孩子
        }
        return 1;
    }
    else
        return 0;                                    // 原树中已有该节点
}

/*
 * 二叉排序树中删除p,
 * 重接它的左/右子树
 */
int Delete(Bitree *p)
{
    Bitree q, s;
    if ((*p)->rchild == NULL)                        // 右子树空则只需重接它的左子树（待删结点是叶子也走此分支)
    {
        q = *p;
        *p = (*p)->lchild;
        free(q);
    }
    else if ((*p)->lchild == NULL)                    // 只需重接它的右子树
    {
        q = *p;
        *p = (*p)->rchild;
        free(q);
    }
    else                                            // 左右子树均不为空
    {
        q = *p;
        s = (*p)->lchild;                            // 向左一步再向右走到头
        while (s->rchild)
        {
            q = s;
            s = s->rchild;
        }
        (*p)->data = s->data;                        // s指向被删结点的直接前驱（将被删结点前驱的值取代被删结点的值）
        if (q != *p)
        {
            q->rchild = s->lchild;                    // 重接q的右子树
        }
        else
        {
            q->lchild = s->lchild;                    // 重接q的左子树
        }
        free(s);
    }
    return 1;
}

/*
 * 若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素结点,
 * 否则返回0
 */
int DeleteBST(Bitree *T, int key)
{
    if (!*T)                                        // 不存在关键字等于key的数据元素
    {
        return 0;
    }
    else
    {
        if (key == (*T)->data)                        // 找到key
        {
            return Delete(T);
        }
        else if (key < (*T)->data)
        {
            return DeleteBST(&(*T)->lchild, key);
        }
        else
        {
            return DeleteBST(&(*T)->rchild, key);
        }
    }
}

void BinarySortTree(int* nums, int length, int key)
{
    clock_t start_time, finish_time;
    double duration;

    printf("BinarySortTree:
");
    Bitree T = NULL;
    for (int i = 0; i < length; ++i)
    {
        InsertBST(&T, nums[i]);
    }
    printf("PreOrder Traverse:
");
    PreOrderTraverse(T);
    printf("
");
    printf("InOrder Traverse:
");
    InOrderTraverse(T);
    printf("
");
    LevelTraverse(T);
    printf("
");

    start_time = clock();
    printf("SearchBST %d:
", key);
    Bitree p;
    int ret = SearchBST(T, key, NULL, &p);
    if (ret == 1)
        printf("Find!
");
    else
        printf("Not Find!
");
    finish_time = clock();
    duration = (double)(finish_time - start_time) / CLOCKS_PER_SEC * 1000;
    printf( "%f ms

", duration );

    printf("Delete %d:
", nums[length/3*2]);
    DeleteBST(&T, nums[length/3*2]);

    printf("PreOrder Traverse:
");
    PreOrderTraverse(T);
    printf("
");
    printf("InOrder Traverse:
");
    InOrderTraverse(T);
    printf("
");
    LevelTraverse(T);
    printf("
");

    return;
}
/*******************************************************************/


/*******************************************************************/
// 平衡二叉树 AVL树
typedef struct AVLNode                                // 节点结构
{
    int data;
    int bf;                                            // 平衡因子
    struct AVLNode *lchild;
    struct AVLNode *rchild;
} AVLNode, *AVLTree;

int LevelTraverseAVL(AVLTree T)                        // 层序遍历
{
    printf("Level Taverse:
");
    if (T == NULL)
    {
        return 0;
    }
    vector<AVLNode *> vec;
    vec.push_back(T);
    int cur = 0;
    int last = 1;

    while (cur < vec.size())
    {
        last = vec.size();
        while (cur < last)
        {
            cout << vec[cur]->data << " ";
            if (vec[cur]->lchild != NULL)
            {
                vec.push_back(vec[cur]->lchild);
            }
            if (vec[cur]->rchild != NULL)
            {
                vec.push_back(vec[cur]->rchild);
            }
            ++ cur;
        }
        cout << endl;
    }
    return 0;
}

int PreOrderTraverseAVL(AVLTree T)                    // 前序遍历
{
    if (T == NULL)
    {
//        printf("Not Find!
");
        return 0;
    }
    printf("%4d ", T->data);
    PreOrderTraverseAVL(T->lchild);
    PreOrderTraverseAVL(T->rchild);
    return 0;
}

int InOrderTraverseAVL(AVLTree T)                    // 中序遍历
{
    if (T == NULL)
    {
//        printf("Not Find!
");
        return 0;
    }
    InOrderTraverseAVL(T->lchild);
    printf("%4d ", T->data);
    InOrderTraverseAVL(T->rchild);
    return 0;
}

/*
 * 递归查找AVLTree T中是否存在key,
 * 指针f指向T的双亲，其初始调用值为NULL
 * 若查找成功，则指针p指向该数据元素结点，并返回1
 * 否则指针p指向查找路径上访问的最后一个结点并返回0
 */
int SearchAVL(AVLTree T, int key, AVLTree f, AVLTree *p)
{
    if (!T)                                            // 不存在
    {
        *p = f;
        return 0;
    }
    else if (key == T->data)                        // 查找成功
    {
        *p = T;
        return 1;
    }
    else if (key < T->data)
    {
        return SearchAVL(T->lchild, key, T, p);        // 在左子树继续查找
    }
    else
    {
        return SearchAVL(T->rchild, key, T, p);        // 在右子树继续查找
    }
}


/* 对以P为根的二叉排序树作右旋处理，
 * 处理之后P指向新的树根结点，
 * 即旋转处理之前的左子树的根结点
 */
void R_Rotate(AVLTree *p)
{
    AVLTree L;
    L = (*p)->lchild;                                // L指向P的左子树根结点
    (*p)->lchild = L->rchild;                        // L的右子树挂接为P的左子树
    L->rchild = (*p);
    *p = L;                                            // P指向新的根结点
}

/* 对以P为根的二叉排序树作左旋处理，
 * 处理之后P指向新的树根结点，
 * 即旋转处理之前的右子树的根结点
 */
void L_Rotate(AVLTree *p)
{
    AVLTree R;
    R = (*p)->rchild;                                // L指向P的右子树根结点
    (*p)->rchild = R->lchild;                        // L的右子树挂接为P的右子树
    R->lchild = (*p);
    *p = R;                                            // P指向新的根结点
}

#define LH +1                                         // 左高
#define EH 0                                          // 等高
#define RH -1                                         // 右高

/*  对以指针T所指结点为根的二叉树作左平衡旋转处理
 *    本算法结束时，指针T指向新的根结点
 */
void LeftBalance(AVLTree *T)
{
    AVLTree L, Lr;
    L = (*T)->lchild;                                // L指向T的左子树根结点
    switch (L->bf)                                    // 检查T的左子树的平衡度，并作相应平衡处理
    {
        case LH:                                    // 新结点插入在T的左孩子的左子树上，要作单右旋处理
            (*T)->bf = L->bf = EH;
            R_Rotate(T);
            break;
        case RH:                                    // 新结点插入在T的左孩子的右子树上，要作双旋处理
            Lr = L->rchild;                            // Lr指向T的左孩子的右子树根
            switch (Lr->bf)                            // 修改T及其左孩子的平衡因子
            {
                case LH:
                    (*T)->bf = RH;
                    L->bf = EH;
                    break;
                case EH:
                    (*T)->bf = L->bf = EH;
                    break;
                case RH:
                    (*T)->bf = EH;
                    L->bf = LH;
                    break;
            }
            Lr->bf = EH;
            L_Rotate(&(*T)->lchild);                // 对T的左子树作左旋平衡处理
            R_Rotate(T);                            // 对T作右旋平衡处理
    }
}

/*  对以指针T所指结点为根的二叉树作右平衡旋转处理
 *    本算法结束时，指针T指向新的根结点
 */
void RightBalance(AVLTree *T)
{
    AVLTree R, Rl;
    R = (*T)->rchild;                                // R指向T的右子树根结点
    switch (R->bf)                                    // 检查T的右子树的平衡度，并作相应平衡处理
    {
        case RH:                                    // 新结点插入在T的右孩子的右子树上，要作单左旋处理
            (*T)->bf = R->bf = EH;
            L_Rotate(T);
            break;
        case LH:                                    // 新结点插入在T的右孩子的左子树上，要作双旋处理
            Rl = R->lchild;                            // Rl指向T的右孩子的左子树根
            switch (Rl->bf)                            // 修改T及其右孩子的平衡因子
            {
                case RH:
                    (*T)->bf = LH;
                    R->bf = EH;
                    break;
                case EH:
                    (*T)->bf = R->bf = EH;
                    break;
                case LH:
                    (*T)->bf = EH;
                    R->bf = RH;
                    break;
            }
            Rl->bf = EH;
            R_Rotate(&(*T)->rchild);                // 对T的右子树作右旋平衡处理
            L_Rotate(T);                            // 对T作左旋平衡处理
    }
}

/*  若在平衡的二叉排序树T中不存在和e有相同关键字的结点，则插入一个
 *     数据元素为e的新结点，并返回1，否则返回0。
 *     若因插入而使二叉排序树失去平衡，则作平衡旋转处理，
 *     布尔变量taller反映T长高与否。
 */
int InsertAVL(AVLTree *T, int e, int* taller)
{
    if (!*T)
    {
        *T = (AVLTree)malloc(sizeof(AVLNode));        // 插入新结点，树“长高”，置taller为1
        (*T)->data = e;
        (*T)->lchild = (*T)->rchild = NULL;
        (*T)->bf = EH;
        *taller = 1;
    }
    else
    {
        if (e == (*T)->data)                        // 树中已存在和e有相同关键字的结点则不再插入
        {
            *taller = 0;
            return 0;
        }
        if (e < (*T)->data)                            // 在T的左子树搜索
        {
            if (!InsertAVL(&(*T)->lchild, e, taller))
            {
                return 0;
            }
            if (*taller)                            // 已插入到T的左子树中且左子树“长高”
            {
                switch ((*T)->bf)                    // 检查T的平衡度
                {
                    case LH:                        // 原本左子树比右子树高，需要作左平衡处理
                        LeftBalance(T);
                        *taller = 0;
                        break;
                    case EH:                        // 原本左、右子树等高，现因左子树增高而使树增高
                        (*T)->bf = LH;
                        *taller = 1;
                        break;
                    case RH:                        // 原本右子树比左子树高，现左、右子树等高
                        (*T)->bf = EH;
                        *taller = 0;
                        break;
                }
            }
        }
        else                                        // 在T的右子树搜索
        {
            if (!InsertAVL(&(*T)->rchild, e, taller))
            {
                return 0;
            }
            if (*taller)                            // 已插入到T的右子树中且右子树“长高”
            {
                switch ((*T)->bf)                    // 检查T的平衡度
                {
                    case LH:                        // 原本左子树比右子树高，现左、右子树等高
                        (*T)->bf = EH;
                        *taller = 0;
                        break;
                    case EH:                        // 原本左、右子树等高，现因右子树增高而使树增高
                        (*T)->bf = RH;
                        *taller = 1;
                        break;
                    case RH:                        // 原本右子树比左子树高，需要作右平衡处理
                        RightBalance(T);
                        *taller = 0;
                        break;
                }
            }
        }
    }
    return 1;
}

void AVLTreeSort(int* nums, int length, int key)
{
    clock_t start_time, finish_time;
    double duration;
    AVLTree T = NULL;
    int taller;
    for (int i = 0; i < length; ++i)
    {
        InsertAVL(&T, nums[i], &taller);
    }
    printf("PreOrder Traverse:
");
    PreOrderTraverseAVL(T);
    printf("
");
    printf("InOrder Traverse:
");
    InOrderTraverseAVL(T);
    printf("
");
    LevelTraverseAVL(T);
    printf("
");

    start_time = clock();
    printf("SearchAVL %d:
", key);
    AVLTree p;
    int ret = SearchAVL(T, key, NULL, &p);
    if (ret == 1)
        printf("Find!
");
    else
        printf("Not Find!
");
    finish_time = clock();
    duration = (double)(finish_time - start_time) / CLOCKS_PER_SEC * 1000;
    printf( "%f ms

", duration );

    return;
}
/*******************************************************************/


/*******************************************************************/
// 散列表
#define NULLKEY -32768

typedef struct
{
    int *element;                                    // 数据元素存储基址，动态分配数组
    int count;                                        // 当前数据元素个数
}  HashTable;

int hashlength = 0;                                    // 散列表表长，全局变量

// 初始化散列表
int InitHashTable(HashTable *H)
{
    hashlength = LengthOfWaitSort;
    H->count = hashlength;
    H->element = (int*)malloc(sizeof(int)*hashlength);
    for (int i = 0; i < hashlength; ++i)
    {
        H->element[i] = NULLKEY;
    }
    return 1;
}

// 散列函数
int Hash(int key)
{
    return key % hashlength;                        // 除留余数法
}

// 插入关键字进入散列表
void InsertHash(HashTable *H, int key)
{
    int addr = Hash(key);                            // 散列地址
    while (H->element[addr] != NULLKEY)                // 如果不为空，则冲突
    {
        addr = (addr+1) % hashlength;                // 开放定址法的线性探测
    }
    H->element[addr] = key;                            // 找到空位后插入
}

// 散列表查找
int SearchHash(HashTable H, int key, int *addr)
{
    *addr = Hash(key);                                // 求散列地址
    while (H.element[*addr] != key)                    // 冲突
    {
        *addr = (*addr + 1) % hashlength;            // 线性探测
        if (H.element[*addr] == NULLKEY || *addr == Hash(key))
        {
            printf("Not Find!
");
            return 0;
        }
    }
    printf("Find in %d
", *addr);
    return 1;
}

void HashSearch(int* nums, int length, int key)
{
    printf("Hash Search:
");
    HashTable H;
    InitHashTable(&H);
    int p;
    for (int i = 0; i < length; ++i)
    {
        InsertHash(&H, nums[i]);
    }
    for (int j = 0; j < length; ++j)
    {
        key = nums[j];
        SearchHash(H, key, &p);
    }
    return;
}
/*******************************************************************/



int main()
{
    clock_t start_time, finish_time;
    double duration;
    srand( (unsigned)time(NULL) );                  // 生成随机数种子
    int length = LengthOfWaitSort;
    int nums[length];
    int temp[length];

    printf("Initial array:
");
    for (int i = 0; i < length; ++i)                // 输出随机数组nums
    {
        nums[i] = rand()%(MaxRandom-1);             // MaxRandom-1以内生成20个随机数
        printf("%4d", nums[i]);
    }

    memcpy(temp, nums, length*sizeof(int));         // temp为无序数组

    QuickSort(nums, length);                        // nums为有序数组
//    int key = 100000;
    int key = nums[length / 3];
    printf("key is %d

", key);

    printf("Static Search:

");
    start_time = clock();
    Sequential_Search(nums, length, key);            // 顺序查找
    finish_time = clock();
    duration = (double)(finish_time - start_time) / CLOCKS_PER_SEC * 1000;
    printf( "%f ms

", duration );

    start_time = clock();
    Sequential_Search2(nums, length, key);            // 哨兵顺序查找
    finish_time = clock();
    duration = (double)(finish_time - start_time) / CLOCKS_PER_SEC * 1000;
    printf( "%f ms

", duration );

    start_time = clock();
    Binary_Search(nums, length, key);                // 二分查找
    finish_time = clock();
    duration = (double)(finish_time - start_time) / CLOCKS_PER_SEC * 1000;
    printf( "%f ms

", duration );

    start_time = clock();
    Insert_Search(nums, length, key);                // 插值查找
    finish_time = clock();
    duration = (double)(finish_time - start_time) / CLOCKS_PER_SEC * 1000;
    printf( "%f ms

", duration );

    start_time = clock();
    Fibonacci_Search(nums, length, key);            // 斐波那契查找
    finish_time = clock();
    duration = (double)(finish_time - start_time) / CLOCKS_PER_SEC * 1000;
    printf( "%f ms

", duration );

    printf("Dynamic Search:

");
    printf("Binary Sort Tree:
");
    BinarySortTree(temp, length, key);                // 二叉排序树

    printf("AVL Tree:
");
    AVLTreeSort(temp, length, key);                    // AVL二叉树

    start_time = clock();
    HashSearch(temp, length, key);                    // 散列表查找
    finish_time = clock();
    duration = (double)(finish_time - start_time) / CLOCKS_PER_SEC * 1000;
    printf( "%f ms

", duration );

    return 0;
}