【数据结构】

快速排序

快排的思想

原理：以第一个数作为轴线，先保存这个值到tmp中，从右向左比较，如果后者小就将当前的数赋值到第一个位置，如果遇到赋值就变换方向，从左向右比较，如果左侧值大于轴线值就赋值，并在此改变比较方向。第一轮比较完之后把tmp赋值到中间的位置，第一轮比较的结果为轴线左边的全部小于轴线值，轴线右边的全部大于轴线值。然后递归再从左侧选出轴线，从右侧选出轴线，依次比较即可。

注：有一个快排的最坏情况就是如果待排序元素是正序或者逆序，就会将除轴值以外的元素分到轴值的一边。

快排参考图

取第一个数作为轴线，然后将它存放tmp中，定义i和j的变量，i初值是0，j的初始值是5。

拿tmp和arr[j]比较，如果后者大，让j–，然后再拿tmp和arr[j]比较。此时后者小。将arr[i]=arr[j]。同时改变方向arr[i]和tmp比较，如果前者的小让i++，如果前者的大，arr[j] = arr[i]。同时改变比较的方向,以此类推，经过第一轮比较就将轴线左侧的值小于轴线，轴线右侧的值大于轴线。递归比较左和右两个。最终将顺序排好即可。

快排的代码实现

#include <stdio.h>
void Show(int* arr, int n)
{
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}
void QuickSort(int* arr, int start, int end)
{
    int i = start, j = end;
    int tmp;
    tmp = arr[i];

    while (i < j) {
        while (i < j && tmp <= arr[j]) {
            j--;
        }
        arr[i] = arr[j];
        while (i < j && arr[i] <=tmp) {
            i++;
        }
        arr[j] = arr[i];
    }
    arr[i] = tmp;

    printf("start = %d,i-1 = %d\n",start,i-1);
    if (start < i - 1)
        QuickSort(arr, start, i - 1);
    if (j + 1 < end)
        QuickSort(arr, j + 1, end);

    return;
}

int main(int argc, const char* argv[])
{
    int arr[] = { 60, 33, 90, 12, 34, 88 };
   
    QuickSort(arr, 0, 5);

    Show(arr, 6);
    return 0;
}

归并排序

#include <stdio.h>

#define M 4
#define N 7
#define K (M + N)

void MergeSort(int* a, int* b, int* c)
{
    int i = 0, j = 0, k = 0;

    while (i < M && j < N) {
        if (a[i] < b[j]) {
            c[k++] = a[i++];
        } else {
            c[k++] = b[j++];
        }
    }

    while (i == M && j != N) {
        c[k++] = b[j++];
    }
    while (j == N && i != M) {
        c[k++] = a[i++];
    }
}
void show(int* c) 
{ 
    for(int i=0;i<K;i++){
        printf("%d\t",c[i]);
    }
    puts("");
}
int main(int argc, const char* argv[])
{
    int a[M] = { 1, 5, 9, 12 };
    int b[N] = { 2, 3, 4, 6, 7, 13, 15 };
    int c[K] = { 0 };

    MergeSort(a, b, c);

    show(c);
    return 0;
}

哈希查找

常见的查找方式

查找方法有顺序查找、折半查找、分块查找、Hash表查找等等

哈希查找的思想接原理

Hash表的含义
Hash表，又称散列表。在前面讨论的顺序、折半、分块查找和树表的查找中，其ASL的量级在O(n)～O(log2n)之间。不论ASL在哪个量级，都与记录长度n有关。随着n的扩大，算法的效率会越来越低。ASL与n有关是因为记录在存储器中的存放是随机的，或者说记录的key与记录的存放地址无关，因而查找只能建立在key的“比较”基础上。

理想的查找方法是：对给定的k，不经任何比较便能获取所需的记录，其查找的时间复杂度为常数级O(C)。这就要求在建立记录表的时候，确定记录的key与其存储地址之间的关系f，即使key与记录的存放地址H相对应：

Hash表的原理

对于数组来说获取成员的方式很简单直接通过下标即可完成，但是数组在编译的时候已经决定了大小。
链表虽然没有成员个数的限制，但是查找的时候挨个比较效率比较低。所以Hash就结合了两者的优点。
既保证了内存的占用，有保证了查找的效率。数组的大小的获取方式是拿数组成员的个数除以0.75。在得到的结果取取出最大的质数作为数组的下标。做种做法尽可能的解决掉了hash冲突的问题。

eg:

数n=11。令装填因子α=0.75，取表长m= n/α =14.6。从0-14.6中取最大的质数用13.
“保留余数法”选取Hash函数（p=13）：
n={23，34，14，38，46，16，68，15，07，31，26}

哈希查找的代码实现

hash.h

#ifndef __HASH_H__
#define __HASH_H__

#include <stdio.h>
#include <stdlib.h>

#define N 13
#define datatype int
typedef struct node{
    datatype data;
    struct node *next;
}hash_t;

hash_t **HashCreate(void);
int HashInsertData(hash_t **t,datatype data);
void HashShow(hash_t **t);
int HashSearch(hash_t **t,datatype data);
#endif

hash.c

#include "hash.h"

hash_t **HashCreate(void)
{
    hash_t **t;

    //分配了13个指针的内存，让t指向它们
    t = (hash_t **)malloc(sizeof(*t)*N);

    //让每个指针都指向一块内存，就是头
    for(int i=0;i<N;i++){
        t[i] =(hash_t *) malloc(sizeof(**t));
        t[i]->data = 0;
        t[i]->next = NULL;
    }

    return t;
}
int HashInsertData(hash_t **t,datatype data)
{
    hash_t *tmp;

    tmp = malloc(sizeof(*tmp));
    tmp->data = data;

    tmp->next = t[data%N]->next;
    t[data%N]->next = tmp;
}
void LinkListShow(hash_t* t)
{
    while (t->next) {
        printf("-%d", t->next->data);
        t = t->next;
    }
    printf("-\n");
}
void HashShow(hash_t **t)
{
    for(int i=0;i<N;i++){
        printf("T[%d]",i);
        LinkListShow(t[i]);
    }
}
int LinkListCheckPosBydata(hash_t *t,datatype data)
{
    int pos=0;

    while(t->next){
        if(t->next->data == data)
            return pos;
        pos++;
        t = t->next;
    }
    return -1;
}
int HashSearch(hash_t **t,datatype data)
{
    return LinkListCheckPosBydata(t[data%N],data);
}

main.c

#include "hash.h"
int main(int argc, char const *argv[])
{
    hash_t **t;
    int k[]={23,34,14,38,46,16,68,15,07,31,26};

    t = HashCreate();

    for(int i=0;i<11;i++){
        HashInsertData(t,k[i]);
    }

    HashShow(t);
    datatype data=100;
    printf("%d的位置是T[%d],pos = %d\n",data,data%N,HashSearch(t,data));
    return 0;
}