目录
一、五大排序
1.1.冒泡排序
1.2.选择排序
1.3.插入排序
1.4.希尔排序
1.5.快速排序
二、哈希表
2.1.哈希表结构的定义
2.2.初始化哈希表
2.3.插入元素
2.4.打印哈希表
2.5.查找元素
2.6.销毁哈希表
三、二分查找法(折半查找法)
时间复杂度: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;
}
时间复杂度: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;
}
时间复杂度 :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;
}
时间复杂度: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;
}
时间复杂度: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;
}
#define INDEX 10
struct list_head hashtable[INDEX];
typedef struct Data
{
struct list_head node;
int data;
}Data_t;
int InitHashTable(void)
{
int i = 0;
for (i = 0; i < INDEX; i++)
{
INIT_LIST_HEAD(&hashtable[i]);
}
return 0;
}
//按照顺序插入
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 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;
}
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;
}
}