C++ 九大排序和三大查找 详解（原理+代码实现，含主函数）

一、查找

二分、哈希、KMP

（一）.二分折半查找

#include<iostream>
using namespace std;
//二分查找法，查找一个数组的元素，并返回所在的位置的下标，
//必须要是一个有序的数组，
int select_arr(int arr[], int len, int arr_value)
{
   
    while (1)
    {
   
        int left = 0;  //数组的左侧下标
        int right = len-1; //数组的右侧下标
        while (left <= right)  
        {
   
            int mid = (left + right) / 2;  //定义中间位的下标
            int mid_value = arr[mid];  //定义中间值的基准值
            if (mid_value == arr_value)  //如果基准值正好等于要查找的值，则自动返回要找的位置
            {
   
                return mid;
            }
            //如果基准值大于要查找的值，表明值在左半边，新的查找范围为中间值-1位，也就是mid-1
            else if (mid_value > arr_value)
            {
   
                right = mid - 1;
            }
            //如果基准值小于要查找的值，表明值在右半边，新的查找范围为中间数+1位，也就是mid+1；
            else if (mid_value < arr_value)
            {
   
                left = mid + 1;
            }
        }
        return -1;
    }
}


int main()
{
   
    //定义一个int数组，并使用二分查找元素
    int arr[10] = {
    1, 3, 5, 7, 9, 10, 16, 46, 88, 91 };
    int weizhi=select_arr(arr, 10, 16);
	cout<<weizhi<<endl;
	system("pause");
    return 0;
}

（二）.哈希查找

步骤
分析数据并定散列函数。
决定哈希冲突的解决办法。
根据散列函数建散列表。
对已经建好的散列表进行查找。
对于以上步骤第一步到第三步是建立散列表的过程。

散列函数
我们一般用求整取余法。

首先我们选取一个数M，这个数最好是质数（非硬性要求），但一定比数据元素个数小，因为在同时间复杂度下占用空间最小为宜，后面会提及。
当M数确定下来后，我们定桶，桶为数据元素除以质数M的各个余数，也就是从0到M-1，元素除以质数M得桶所代表的余数，我们就把这个数据元素放入桶内，而且每个桶里只能放一个元素。
而当数据元素除以质数M得余数相同时，由于桶内只能放一个元素，所以当出现余数相同的元素时而不能放入桶内时，就产生了哈希冲突。当我们解决完哈希冲突后，也就建完散列表，就可以查找了！
解决哈希冲突
开放地址法
线性探测法：在冲突位置顺次后延一位放入桶内。也就是说同为余数4的话，后来的数据就放入余数5的桶里。
线性补偿法：首先定一个步长，遇到冲突时，按步长顺次后延步长的长度放入桶内。
随机探测法：找个随机数来当步长，解决冲突如上个办法。
拉链法：
在每个桶内建立一个头添加的链表，每个桶内装的是相应链表的头指针，将后来的元素依次头添加在链表上。
举例图示
例如数组｛19，27，55，41，82，89，16，9，22，98，104，1，2，205，46｝

#include<iostream>
using namespace std;


typedef struct node
{
   
    int nValue;
    int nIndex;
    struct node *pNext;
}MyHash;

#define M 7

MyHash **CreateHashTable(int arr[],int nLength)
{
   
    MyHash **pHash = NULL;
    MyHash *pTemp = NULL;
    int i;
    int nIndex;
    //申请哈希表表头
    pHash = (MyHash**)malloc(sizeof(MyHash*) * M);
    memset(pHash,NULL,sizeof(MyHash*) * M);

    //拉链法
    for(i = 0;i<nLength;i++)
    {
   
        nIndex = arr[i]%M;
        pTemp = (MyHash*)malloc(sizeof(MyHash));
        pTemp->nIndex = i;
        pTemp->nValue = arr[i];

        //头添加
        pTemp->pNext = pHash[nIndex];
        pHash[nIndex] = pTemp;
    }
    return pHash;
}

int HashChop(int arr[],int nLength,int nNum)
{
   
    MyHash **pHash = NULL;
    int nIndex;
    MyHash *pMark = NULL; 

    if(arr == NULL || nLength <=0) 
        abort();

    //建哈希表
    pHash = CreateHashTable(arr,nLength);

    //查询
    nIndex = nNum%M;
    pMark = pHash[nIndex];

    //遍历链表
    while(pMark)
    {
   
        if(pMark->nValue == nNum)
        {
   
            return pMark->nIndex;
        }
        else
        {
   
            pMark = pMark->pNext;
        }
    }

    return -1;
}

int main()
{
   
	int arr[]={
   1,5,6,96,23,78,24