数据结构---五大排序---哈希表---二分查找法

踢球的程序猿

已于 2024-09-02 21:03:06 修改

阅读量242

点赞数 8

文章标签：数据结构散列表排序算法

于 2024-09-02 21:02:41 首次发布

本文链接：https://blog.csdn.net/m0_65301172/article/details/141829374

版权

一、五大排序

1.1.冒泡排序

时间复杂度：o(n^2)

稳定性：稳定

int BubbleSort(int *pArray, int MaxLen)
{
    int j = 0;
    int i = 0;
    int temp = 0;

    for (j = 0; j < MaxLen-1; j++)
    {
        for (i = 0; i < MaxLen-1-j; i++)
        {
            if (pArray[i] > pArray[i+1])
            {
                temp = pArray[i];
                pArray[i] = pArray[i+1];
                pArray[i+1] = temp;
            }
        }
    }

    return 0;
}

1.2.选择排序

时间复杂度：o(n^2)

稳定性：不稳定

int SelectSort(int *pArray, int MaxLen)
{   
    int Min = 0;
    int Temp = 0;
    int i = 0;
    int j = 0;

    for (j = 0; j < MaxLen-1; j++)
    {
        Min = j;
        for (i = j+1; i < MaxLen; i++)
        {
            if (pArray[i] < pArray[Min])
            {
                Min = i;
            }
        }
        if (Min != j)
        {
            Temp = pArray[j];
            pArray[j] = pArray[Min];
            pArray[Min] = Temp;
        }
    }

    return 0;
}

1.3.插入排序

时间复杂度：O(n^2) 已经有序的数据使用插入排序时间复杂度为：O(n)

稳定性：稳定

int InsertSort(int *pArray, int MaxLen)
{
    int i = 0;
    int j = 0;
    int Temp = 0;

    for (j = 1; j < MaxLen; j++)
    {
        Temp = pArray[j];
        for (i = j; i > 0 && Temp < pArray[i-1]; i--)
        {
            pArray[i] = pArray[i-1];
        }
        pArray[i] = Temp;
    }

    return 0;
}

1.4.希尔排序

时间复杂度：O(nlogn)

稳定性：不稳定

int ShellSort(int *pArray, int MaxLen)
{
    int step = 0;
    int i = 0;
    int j = 0;
    int temp = 0;

    for (step = MaxLen / 2; step > 0; step /= 2)
    {
        for (j = step; j < MaxLen; j++)
        {
            temp = pArray[j];
            for (i = j; i >= step && temp < pArray[i-step]; i -= step)
            {
                pArray[i] = pArray[i-step];
            }
            pArray[i] = temp;
        }
    }

    return 0;
}

1.5.快速排序

时间复杂度：O(nlogn)

稳定性：不稳定

int QuickSort(int *pArray, int Low, int High)
{
    int Key = 0;
    int j = High;
    int i = Low;

    Key = pArray[Low];
    while (i < j)
    {
        while (i < j && pArray[j] >= Key)
        {
            j--;
        }
        pArray[i] = pArray[j];
        while (i < j && pArray[i] <= Key)
        {
            i++;
        }
        pArray[j] = pArray[i];
    }
    pArray[i] = Key;

    if (i-1 > Low)
    {
        QuickSort(pArray, Low, i-1);
    }
    if (i+1 < High)
    {
        QuickSort(pArray, i+1, High);
    }

    return 0;
}

二、哈希表

2.1.哈希表结构的定义

#define INDEX   10

struct list_head hashtable[INDEX];

typedef struct Data
{
    struct list_head node;
    int data;
}Data_t;

2.2.初始化哈希表

int InitHashTable(void)
{
    int i = 0;

    for (i = 0; i < INDEX; i++)
    {
        INIT_LIST_HEAD(&hashtable[i]);
    }

    return 0;
}

2.3.插入元素

//按照顺序插入
int compare(struct list_head *pNewNode, struct list_head *pTmpNode)
{
    if (NULL == pTmpNode)
    {
        return 1;
    }

    return list_entry(pNewNode, Data_t, node)->data - list_entry(pTmpNode, Data_t, node)->data;
}

//插入哈希表
int InsertHashTable(int Num)
{
    int index = 0;
    Data_t *pNewNode = NULL;

    //申请节点 
    pNewNode = malloc(sizeof(Data_t));
    if (NULL == pNewNode)
    {
        return -1;
    }
    pNewNode->data = Num;

    //获得插入数据的键值
    index = Num % INDEX;

    //插入数据
    list_add_order(&pNewNode->node, &hashtable[index], compare);

    return 0;
}

2.4.打印哈希表

int ShowHashTable(void)
{
    int index = 0;
    Data_t *pData = NULL;
    
    for (index = 0; index < INDEX; index++)
    {
        printf("%d:", index);

        list_for_each_entry(pData, &hashtable[index], node)
        {
            printf("%d ", pData->data);
        }
        printf("\n");
    }

    return 0;
}

2.5.查找元素

int FindHashTable(int Num)
{
    int index = 0;
    Data_t *pData = NULL;
    int ret = 0;

    index = Num % INDEX;
    
    list_for_each_entry(pData, &hashtable[index], node)
    {
        if (pData->data == Num)
        {
            ret = 1;
            break;
        }

        if (pData->data > Num)
        {
            ret = 0;
            break;
        }
    }
    
    return ret;
}

2.6.销毁哈希表

int DestroyHashTable()
{
    int i = 0;
    Data_t *pTmpNode = NULL;
    Data_t *pNextNode = NULL;

    for (i = 0; i < INDEX; i++)
    {
        list_for_each_entry_safe(pTmpNode, pNextNode, &hashtable[i], node)
        {
            free(pTmpNode);
        }
    }

    return 0;
}

三、二分查找法（折半查找法）

只适合顺序表

折半查找的基本思想：首先将给定值key与表中中间位置的元素（mid的指向元素）比较。mid=low+high/2（向下取整）

若key与中间元素相等，则查找成功，返回该元素的存储位置，即mid；
若key与中间元素不相等，则所需查找的元素只能在中间元素以外的前半部分或后半部分。（至于是前半部分还是后半部分要看key与mid所指向元素的大小关系）
a.在查找表升序排列的情况下，若给定值key大于中间元素则所查找的元素只可能在后半部分。此时让low=mid+1；
b.若给定值key小于中间元素则所查找的元素只可能在前半部分。此时让high=mid-1；

int MidSearch(int *pArray, int Low, int High, int tmpdata)
{
    int Mid = 0;

    if (Low > High)
    {
        return -1;
    }

    Mid = (Low + High) / 2;
    if (tmpdata < pArray[Mid])
    {
        return MidSearch(pArray, Low, Mid-1, tmpdata);
    }
    else if (tmpdata > pArray[Mid])
    {
        return MidSearch(pArray, Mid+1, High, tmpdata);
    }
    else if (tmpdata == pArray[Mid])
    {
        return Mid;
    }
}