排序|数据结构

#define MAXSIZE 20
typedef int RedType
typedef struct 
{
	KeyType key;
	InfoType otherinfo; 
}RedType;

typedef struct
{
	RedType r[MAXSIZE+1];
	int length;
}SqLIst;

插入排序

直接插入排序

void StraightInsertSort(SqLIst &L)
{
	for(i=2;i<L->length;i++)
	{
		if(L.r[i-1].key>L.r[i].key)
		{
			//如果小的话，则与他比较的往后移
			L.r[0]=L.r[i];
			L.r[i]=L.r[i-1];
			for(j=i-2;L.r[0].key<L.r[j].key;j--)
			{
				if(L.r[j-1].key>L.r[j].key)
				{
					L.r[j+1] = L.r[j];
				}
			}
			L.r[j+1]=L.r[0]
		}
	}
}

void ShellSort(SqLIst &L,int dt[],int t)
{
	for(i=0;i<;i++)
	{
		StraightInsertSort(L,dt[k]);
	}
}

折半插入排序

void BInsertSort(SqLIst &L)
{
	
	for(i=2;i<L.length;i++)
	{
		L.r[0]=L.r[i];
		low=1;
		high=i-1;
		while(low<high)
		{
			m=(low+high)/2;
			if(L.r[m].key>L.r[0].key)high=m-1;
			else low=m+1;
		}
		for(j=i-1;j>=high+1;j--)
		{
			L.r[j+1]=L.r[j];
		}
		L.r[high+1]=L.r[0];
	}
}

希尔排序

void SheLLInsert(SqList &L,int dk)
{
	for(i=dk+1;i<L.length;i++)
	{
		if(L.r[i].key<L.r[i-dk].key)
		{
			L.r[0]=L.r[i];
			for(j=i-dk;j>0 && L.r[0].key<L.r[j].key;j-=dk)
			{
				L.r[j+dk]=L.r[j];
			}
		}
		
	}
}

冒泡排序

void BubbleSort(SqList &L)
{
	for(i=1;i<L.length;i++)
	{
		for(j=1;j<L.length-i;j++)
		{
			if(L.r[j]>L.r[j+1])
			{
				L.r[0] = L.r[j];
				L.r[j] = L.r[i];
				L.r[i] = L.r[0];
			}
		}
	}
}

引入falg进行改进

void BubbleSort(SqList &L)
{
	m = L.length-1;
	flag=1;
	while(m>0 && flag==1)
	{
		flag=0;
		for(j=1;j<=m;j++)
		{
			if(L.r[j].key>L.r[j+1].key)
			{
				flag=1;
			    L.r[0].key = L.r[j].key;
				L.r[j].key = L.r[j+1].key;
				L.r[j+1].key = L.r[0].key;
			}
		}
		--m;
	}
}

4.选择

简单选择排序

void SelectSort(SqList &L)
{
	for(i=1;i<L.length;i++)
	{
		k=i;
		for(j=i+1;j<L.length;j++)
		{
			if(L.r[k].key>L.r[j].key)
			{
				k=j;
			}
		}
		if(k!=i)
		{ 
			temp=L.r[i];
			L.r[i]=L.r[k];
			L.r[k]=temp;
		}
	}
}

简单选择排序，移动次数很少了，但是要考虑，减少它的比较次数，如果利用前面比较所得到的信息，就更好了

堆排序（Heap Sort）

堆排序是一种树形选择排序，在排序过程中，将待排序的记录看成是一颗完全二叉树的顺序存储结构，利用完全二叉树中双亲和孩子之间的内在关系，在当前无序的序列中选择关键字最小（大）的记录

void HeapAdjust(SqList &L,int s,int m)
{
	rc=L.r[s];
	for(j=2*s;j<=m;j*=2)
	{
		if(j<m&&L.r[j].key<L.r[j+1].key)	j++;
		if(rc.key>=L.r[j].key)	break;
		L.r[s]=L.r[j];    //给头节点赋值
		s=j;              //把原本头结点的值交换给j
	}
	L.r[s]=rc;
}

void CreateHeap(SqList &L)
{
	//从下往上，把大的给弄上来
	n=L.length;
	for(i=n/2;i>=1;i--)
	{
		HeapAdjust(L,i,n);
	}
}

void HeapSort(SqList &L)
{
	CreateHeap(L);
	for(i=L.length;i>1;--i)
	{
		t = L.r[i];
		L.r[i] = L.r[1];
		L.r[1] = t;
		HeapAdjust(L,1,i-1);
	}
}

归并排序

void Merge(RedType R[],RedType T[],int low,int mid,int high)
{
	i=low;
	j=mid+1;
	k=low;
	while(i<=mid&&j<=high)
	{
		if(R[i]<R[j]) T[k++]=R[i++];
		else	T[k++]=R[j++];
	}
	while(i<=mid)
	{
		T[k++]=R[i++];
	}
	while(j<=high)
	{
		T[k++]=R[j++];
	}
}

void Msort(RedType R[],RedType T[],int low,int high)
{
	if(low==high)	T[low]=R[low];
	else{
		mid=(low+high)/2;
		Msort(R,T,low,mid);
		Msort(R,T,mid+1,high);
		void Merge(T,S,low,mid,high);
	}
}

void MergeSort(SqList &L)
{
	MSort(L.r,L.r,1,L.length);                 
}