查找 复习

（1）顺序表上的查找

时间效率O（n）

#include<iostream>
#define MAX 100
using namespace std;

int Seq_Search(int data[], int kx, int n) {
    int i = 1;
    while (i <= n && data[i] != kx) {
        i++;
    }
    if (i > n) {
        return 0;
    }
    else {
        return i;
    }
}

int Seq_Search2(int data[], int kx, int n) {
    data[0] = kx;
    int i = n;

    while (data[i] != data[0]) {
        i--;
    }
    return i;
}

int main()
{
    int n = 6, kx = 4;
    int data[MAX] = { 0,1,2,3,4,5,6 };

    return 0;
}

（2）单链表的查找

时间复杂度O（n）

#include<iostream>
#define MAX 100
using namespace std;

typedef struct List {
    int data;
    List* next;
};

List* creatList(int n) {
    List* head = (List*)malloc(sizeof(List));
    head->next = NULL;

    int temp;
    for (int i = 0; i < n; i++) {
        List* Node = (List*)malloc(sizeof(Node));
        cin >> temp;
        Node->data = temp;
        Node->next = NULL;

        Node->next = head->next;
        head->next = Node;
    }

    return head;
}

List* Search(List* head, int kx) {
    List* p = head->next;
    while (p && p->data != kx) {
        p = p->next;
    }
    return p;
}

int main()
{
    int n, kx;
    cin >> n >> kx;

    List* head = creatList(n);
    List* result = Search(head, kx);

    if (result) {
        cout << result->data;
    }
    else {
        cout << "Not Found";
    }

    return 0;
}

（3）折半查找（待查找的表必须是有序的）

时间复杂度O（log2（n））

折半查找的数据元素的查找过程，可以用二叉树来描述，这种描述查找过程的二叉树为判定树。

#include<iostream>
#define MAX 100
using namespace std;

int Binary_Search(int data[], int kx, int n) {
    int low = 1;
    int high = n;
    int mid;
    while (low <= high) {
        //mid = (low + high) / 2;
        mid = low + (high - low) / 2;//上面的可能会计算溢出
        if (data[mid] == kx) {
            return mid;
        }
        else if (data[mid] < kx) {
            low = mid + 1;
        }
        else {
            high = mid - 1;
        }
    }
    return 0;
}

int main()
{
    int n = 13, kx = 14;
    int data[MAX] = { 0,7,14,18,21,23,29,31,35,38,42,46,49,52 };
    int result = Binary_Search(data, kx, n);
    cout << result;

    return 0;
}

（4）二叉排序树

2023.1.9 学习总结

（5）平衡二叉树

#include<iostream>
#define MAX 100
using namespace std;

typedef struct avlnode {
    int data;
    int df;
    avlnode* lchild, * rchild;
};

void LL_rotate(avlnode** p) {
    avlnode* lp;
    lp = (*p)->lchild;
    (*p)->lchild = lp->rchild;
    lp->rchild = (*p);
    *p = lp;
    (*p)->df = 0;
    (*p)->rchild->df = 0;
}

void RR_rotate(avlnode** p) {
    avlnode* rp;
    rp = (*p)->rchild;
    (*p)->rchild = rp->lchild;
    rp->lchild = (*p);
    (*p) = rp;
    (*p)->df = 0;
    (*p)->lchild->df = 0;
}

void LR_rotate(avlnode** p) {
    avlnode* lp, * rlp;
    int r;
    lp = (*p)->lchild;
    rlp = lp->rchild;
    if (rlp->df == 1) {
        r = 1;
    }
    else {
        r = 2;
    }
    RR_rotate(&lp);
    LL_rotate(p);
    if (r == 1) {
        (*p)->lchild->df = 0;
        (*p)->rchild->df = -1;
    }
    else {
        (*p)->lchild->df = 1;
        (*p)->rchild->df = 0;
    }
    (*p)->df = 0;
}

void RL_rotate(avlnode** p) {
    avlnode* rp, * lrp;
    int r;
    rp = (*p)->rchild;
    lrp = rp->lchild;
    if (lrp->df == 1) {
        r == 1;
    }
    else {
        r == 2;
    }
    LL_rotate(&rp);
    RR_rotate(p);
    if (r == 1) {
        (*p)->lchild->df = 0;
        (*p)->rchild->df = -1;
    }
    else {
        (*p)->lchild->df = 1;
        (*p)->rchild->df = 0;
    }
    (*p)->df = 0;
}

int main()
{
    

    return 0;
}

（6）散列表

经过散列函数变换后，可能将不同的关键码映射到同一个散列地址上，叫冲突

映射到同一散列地址上的关键码称为同义词

常用的散列函数：

1.直接定址法

Hash（key）=a*key+b

2.除留余数法

Hash（key）=key%p

3.乘余取整法

处理冲突的方法：

1.开放定址法（线性探测法，二次探测法，双散列函数探测法）

线性探测法：如果出现冲突的话，增量为i，第i次的探测的地址为H(i)=(Hash(key)+i)%m

二次探测法：采用开放定址法处理冲突中的二次探测再散列（也即是题目中的二元探测法）,则哈希函数变为Hash(key） = (Hash(key) + d) % 11，其中d = 1^2, -1^2, 2^2, -2^2, 3^2,……，则开始计算。（注意：这里所有涉及负数的，比如-2^2,，是  -（2^2））

设哈希表长为11，哈希函数为Hash (key)=key%11。存在关键码{43,7,29,22,16,92,44,8,19}，采用二次探测法处理冲突，建立的hash表为（ ）

对于43，代入公式为Hash(43) = 43 % 11 = 10, 则地址为10；

对于7，代入公式为Hash(7) = 7 % 11 = 7,则地址为7；

对于29，代入公式为Hash(29) = 29 % 11 = 7, 与7冲突，则采用二次探测进行消除冲突， 继续(7 + 1) % 11 = 8，没有冲突，则地址为8；

对于22，代入公式Hash(22) = 22 % 11 = 0, 则地址为0；

对于16，代入公式Hash(16) = 16 % 11 = 5, 则地址为5；

对于92，代入公式Hash(92) = 92 % 11 = 4,则地址为4；

对于44，代入公式Hash(44) = 44 % 11 = 0, 与22的地址冲突，则继续(0 + 1) % 11 = 1,没有冲突，则地址为1；

对于8， 代入公式Hash(8) = 8 % 11 = 8, 与29有冲突，则继续(8 + 1) % 11 = 9, 没有冲突，则地址为9；

对于19，代入公式Hash(19) = 19 % 11 = 8. 与 29有冲突，则继续(8 + 1) * 11 = 9, 与8有冲突，继续(8 - 1) % 11 = 7, 与7有冲突，则继续(8 + 4) % 11 = 1, 与44有冲突，则继续(8 - 4) % 11 = 4, 与92有冲突，则继续(8 + 9) % 11 = 6, 没有冲突，则地址为6.

所以最后得到的Hash表为下图所示：

2.拉链法

#include<iostream>
#define MAX 1000
using namespace std;

typedef struct hnode {
    int data;
    hnode* next;
}HNode;
HNode* HashTbl[MAX];

int Hash(int d) {
    int result;
    result = d % 10;
    return result;
}

void creat(HNode* LHashTbl[],int * eptr) {
    int d;
    HNode* q;
    for (int i = 0; i < MAX; i++) {
        LHashTbl[i] = NULL;
    }
    while (*eptr != 0) {
        d = Hash(*eptr);
        q = (HNode*)malloc(sizeof(HNode));
        q->data = *eptr;
        q->next = LHashTbl[d];
        LHashTbl[d] = q;
        eptr++;
    }
}

HNode* Search(HNode* LHashTbl[], int kx) {
    int d;
    HNode* p;
    d = Hash(kx);
    p = LHashTbl[d];
    while (p) {
        if (p->data == kx) {
            break;
        }
        else {
            p = p->next;
        }
    }
    return p;
}

int main()
{
    int array[MAX] = { 2,4,12,5,6,7,1,9 };
    int* eptr = array;
    creat(HashTbl, eptr);
    HNode* temp;
    if (temp = Search(HashTbl, 12)) {
        cout << temp->data;
    }
    else {
        cout << "Not Found";
    }

    return 0;
}

3.公共溢出区  

设置两个表，第一个表正常存放，如果出现冲突，就放到第二个表里。