排序（链表）

链表结构体定义

typedef struct SqList
{
	int *elem;
	int length;
}SqList;

初始化线性表

void InitSq(SqList &L)
{
	L.elem=(int*)malloc(sizeof(int));
	if(!L.elem)
		exit(-1);
	L.length=0;
}

建表

void create(SqList &L,int n)
{
	int e;
	for(int j=0;j<n;j++)
	{
		scanf("%d",&e);
		L.elem[j]=e;
		L.length=j+1;
	}
}

输出线性表

void show(SqList L,int n)
{
	int j;
	int k;
	printf("该线性表为");
	for(j=0;j<n-1;j++)
	{
		k=L.elem[j];
		printf("%d\t",k);
	}
	if(j==n-1&&n>0)
	{
		k=L.elem[j];
		printf("%d",k);
	}
	printf("\n");
}

直接插入排序 平均O(n²)

void insertSort(SqList &L)
{
	int temp;//用于交换
	int i,j;
	for( i=1;i<L.length;i++)//从第二个元素开始比较 
	{
		temp=L.elem[i];
		j=i-1;//j是已排好序列的最后一个
		while(j>=0&&L.elem[j]>temp)//比待排元素大才后移
		{
			L.elem[j+1]=L.elem[j];
			--j;
		}
		L.elem[j+1]=temp;//找到插入位置		
	}
}

折半插入排序

void BinarySort(SqList *&L)
{
	int i,j,low,high,mid;	
	int temp;
	for(i=1;i<=L.length;i++)
	{
		temp=L.elem[i];
		low=0;high=i-1;
		while(low<=high)
		{
			mid=(low+high)/2;
			if(L.elem[i]<mid)
				high=mid-1;
			else
				low=mid+1;				
		}
		for(j=i-1;j>=low;j--)//元素后移 在low处插入
		{
			L.elem[j+1]=L.elem[j];
		}
		L.elem[low]=temp;
	}
	

希尔排序

void shellSort(SqList *&L)
{
	int i,j,d;
	int temp;
	for(d=L.length/2;d>=1;d=d/2)
	{
		for(i=d+1;i<=L.length;++i)
		{
			if(L.elem[i]<L.elem[i-d])
			{
				temp=L.elem[i];
				for(j=i-d;j>0&&temp<L[j];j-=d)
				{
					L[j+d]=L[j];
				}
				L[j+d]=temp;//插入 
			}
		}
	
	}
}

冒泡排序

int bubbleSort(SqList &L)
{
	int flag;//交换标志
	int temp;
	for(int i=L.length-1;i>=1;--i)//i是最后一个参与比较的元素下标
	{
		flag=0;
		for(int j=0;j<=i;j++)
		{
			if(L.elem[j]>L.elem[j+1])//当前元素大于后继元素 交换
			{
				temp=L.elem[j];
				L.elem[j]=L.elem[j+1];
				L.elem[j+1]=temp;
				flag=1;
			}
		}
		if(flag==0)//如果一趟排序没有出现数据交换，程序结束
			return 1;
	}
}

快速排序

void quickSort(SqList &L,int low,int high)
{	
	int i=low;
	int j=high;
	int temp;
	if(low<high)
	{
		temp=L.elem[low];
		while(i<j)
		{
			while(i<j&&L.elem[j]>=temp)
				--j;
			if(i<j)
			{
				L.elem[i]=L.elem[j];
				++i;
			}
			while(i<j&&L.elem[i]<=temp)
				++i;
			if(i<j)
			{
				L.elem[j]=L.elem[i];
				--j;
			}
		}
		L.elem[i]=temp;//i=j时，填值
		quickSort(L,low,i-1);//递归排序左半边
		quickSort(L,i+1,high);//递归排序右半边		
	}
}

简单选择排序(不稳定 时间复杂度与原始顺序无关 n个元素n-1次对比)
从无序序列中选择最小的关键字与无序序列中的第一个关键字进行交换。

void selectSort(SqList &L)
{
	int k;//k始终指向最小结点
	int temp;//中间变量用于交换
	for(int i=0;i<L.length;i++)//从第一个结点开始遍历比较
	{
		k=i;//k初始化为当前结点
		for(int j=i+1;j<L.length;j++)//将i与i之后的结点进行遍历比较
		{
			if(L.elem[j]<L.elem[k])
				k=j;//k指向较小节点
		}
		temp=L.elem[i];//利用temp进行交换
		L.elem[i]=L.elem[k];
		L.elem[k]=temp;
	}
}

应用

void main()
{
	SqList L;
	int n;
	InitSq(L);
	printf("请输入顺序表长度");
	scanf("%d",&n);
	create(L,n);
	show(L,L.length);
	//bubbleSort(L);
	quickSort(L,0,L.length-1);
	show(L,L.length);	
}

堆排序=堆顶与堆底元素互换+堆调整
将堆顶元素与堆底元素互换即将堆顶元素加入有序交换子序列
基于大根堆得到递增序列，基于小根堆得到递减序列；
堆增加元素：将元素插入堆底，对堆进行调整；
堆删除元素：用堆底元素替代该节点，对堆进行调整