算法也能降低时间复杂度???—————算法延伸

先来补充一下哈希表遗留的一些问题：

1.哈希表的打印：

哈希表的各个基础节点存储在指针数组中，我们可以先把指针数据的元素接出来再去遍历每一个节点的元素；

c 复制代码

void hashtableshow(void)
{
	int i=0;
	node_t ptemp = NULL;
	for(i=0;i<10;i++)
	{
		printf("%d\n",i);
		ptemp = phashtable[i];
		while(ptemp != NULL)
		{
			printf("%d\n",ptemp->data);
			ptemp = ptemp->pnext;
		}
		printf("\n");
	}
}

数据结构与算法

分类：

按时间复杂度由高到低排列：

1.冒泡排序：

2.选择排序：

3.插入排序：

4.希尔排序：

5.快速排序：

具体的步骤展示：

1.冒泡排序：

c 复制代码

void bubblesort(int *p,int len)
{
	int i = 0;
	int j = 0;
	for(j=0;i<len-1;i++)
	{	
		for(i=0;i<len-1-j;i++)
		{
			if(p[i] < p[i+1])
			{
				t = p[i];
				p[i] = p[i+1];
				p[i+1] = t;
			}
		}
	}
	return;
}

选择排序：

c 复制代码

void selectsort(int p*,int len)
{	
	int i=0,j=0;
	int no=0;
	for(j=0;j<len-1;j++)
	{ 
		no = j;
		for(i=j+1;i<len;i++)
		{
			if(p[no] > p[i])
			{
				no = i;
			}
		}
		if(no != j)
		{
			t = p[no];
			p[no] = p[j];
			p[j] = t;
		}
	}
	return;
}

3.插入排序：

c 复制代码

void insersort(int *phead,int len)
{
	int i=0,j=0;
	int tem;
	for(j=1;j<len;j++)
	{
		tem = phead[j];
		for(i=j;i>0 && phead[i-1] > tem;i--)
		{
			phead[i] = phead[i-1];
		}
		phead[i] = tem;
	}
	return;
}

4.希尔排序：（插入排序的优化）

先将数组变为大致有序
设置步长，步长取数组长度的一半
循环取对半步长，直至取到0；

c 复制代码

void shellsort(int *phead,int len)
{
	int step = 0;
	int i = 0;
	int j = 0;
	int tem=0;
	for(step = len/2;step>0;step /= 2)
	{
		for(j=step;j<len;j++)
		{
			tem = phead[j];
			for(i=j;i>step-1 && phead[i-step] > tem; i-=step)
			{	
				phead[i] = phead[i-step];
			}
			phead[i] = tem;
		}
	}
	retuen;
}

5.快速排序：

定义键值指向最左侧元素；

c 复制代码

void quicksort(int *p,int low,int high)
{
	int i=low;
	int j=high;
	int key = p[low];
	while(i < j)
	{
		while(i < j && p[j] >= key)
		{
			j--;
		}
		p[i] =  p[j];
		while(i < j && p[i] <= key)
		{
			i++;
		}
		p[j] = p[i];
	}
	p[i] = key;
	if(low < i-1)
	{
		quicksort(p,low,i-1);
	}
	if(i+1 < high)
	{
		quicksort(p,i+1,high);
	}
	return;
}

排序算法稳定性评估

相同大小元素在排序完后，相对位置是否发生改变

若未改变则为稳定

若改变则为不稳定

排序方式和	时间复杂度	稳定性
冒泡排序	O(n^2)	稳定
选择排序	O(n^2)	稳定
插入排序	O(n^2)	稳定
希尔排序	O(n*logn)	稳定
快速排序	O(n*logn	稳定