1、哈希表
1.1创建哈希表
哈希表:
将数据通过哈希算法映射称为一个键值
存时在键值对应的位置存储
取时通过键值对应的位置查找
哈希冲突(哈希碰撞):多个数据通过哈希算法映射成同一个键值
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "list.h"
#define INDEX 10
struct list_head hashtable[INDEX];
typedef struct Data
{
struct list_head node;
int data;
}Data_t;
//按照顺序插入
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;
}
//打印哈希表
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;
}
//初始化所有节点
int InitHashTable(void)
{
int i = 0;
for (i = 0; i < INDEX; i++)
{
INIT_LIST_HEAD(&hashtable[i]);
}
return 0;
}
//查找数据
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;
}
//销毁Hash表
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;
}
int main(void)
{
int i = 0;
int tmp = 0;
srand(time(NULL));
InitHashTable();
for (i = 0; i < 30; i++)
{
InsertHashTable(rand() % 100);
}
ShowHashTable();
printf("请输入要查找的数据:\n");
scanf("%d", &tmp);
if (FindHashTable(tmp))
{
printf("%d 存在!\n", tmp);
}
else
{
printf("%d 不存在!\n", tmp);
}
DestroyHashTable();
return 0;
}
2、五大排序
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))
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(n))
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;
}
3、二分查找(需要在以经排好序的情况下使用)
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;
}
}