数据结构--内排序

排序种类	排序子类	最坏时间复杂度	最好时间复杂度	平均时间复杂度	空间复杂度	是否稳定
插入排序	直接插入排序	n2	n	n2	1	稳定
	shell排序(增量每次除以3)	n1.5	n1.5	n1.5	1	不稳定
交换排序	冒泡排序	n2	n	n2	1	稳定
	快速排序	n2	nlogn	nlogn	n(平均logn)	不稳定
选择排序	直接选择排序	n2	n2	n2	1	不稳定
	堆排序	nlogn	nlogn	nlogn	1	不稳定
分配排序	桶排序	n+m	n+m	n+m	n+m	稳定
	基数排序	d(n+r)	d(n+r)	d(n+r)	n+r
	索引排序
归并排序	归并排序	nlogn	nlogn	nlogn	n	稳定

直接插入排序

template<class Record>
void InsertSort(Record Array[], int n)
{
   int i,j;
   Record tempRecord;
   for(i=1;i<n;i++)
   {
   	tempRecord= Array[i];
   	j=i-1;
   	while(j>=0&&Array[j]>tempRecord)
   	{
   		Array[j+1]=Array[j];
   		j--;
   	}
   	Array[++j]=temp;
   }
}

Shell排序

template<class Record>
void ShellSort(Record Array[], int n)
{
	int i,delta;
	for(delta=n/2;delta>=1;delta/=2)
	{
		for(i=0;i<delta;i++)
		{
			ModInsSort(&Array[i],n-i,delta);//一趟插入排序
		}
	}
}
template<class Record>
void sort(Record Array[], int n ,int delta)
{
	int i,j;
	for(i=delta;i<n;i+=delta)
	{
		for(j=i;j>=delta;j-=delta)
		{
			if(Array[j]<Array[j-delta])
			{
				swap(Array,j,j-delta);
			}
			else
				break;
		}
	}
	
}

冒泡排序

template<class Record>
void BubbleSort(Record Array[], int n)
{
	bool noSwap=false;
	int i,j;
	for(i=0;i<n-1;i++)
	{
		noSwap=true;
		for(j=n-1;j>i;j--)
		{
			if(Array[j]<Array[j-1])
			{
				swap(Array,j,j-1);
				noSwap=false;
			}
		}
		if(noSwap)
		 	return;
	}
}

快速排序

template<class Record>
void QuickSort(Record Array[], int left, int right)
{
	if(right<=left)
	{
		return;
	}
	int pivot = SelectPivot(left,right);
	swap(Array,right,pivot);
	pivot = Partition(Array,left,right);
	QuickSort(Array,left,pivot-1);
	QuickSort(Array,pivot+1,right);
}
int SelectPivot(int left, int right)
{
	return (left+right)/2;
}
template<class Record>
int Partition(Record Array[],int left,int right)
{
	int l=left;
	int r=right;
	Record tempRecord = Array[right];
	while(l!=r)
	{
		while(Array[l]<=tempRecord && l<r)
		{
			l++;
		}
		if(l<r)
		{
			Array[r]=Array[l];
			r--;
		}
		while(Array[r]>=tempRecord && l<r)
		{
			r--;
		}
		if(l<r)
		{
		   Array[l]=Array[r];
		   l++;
		}
	}
	Array[l]=tempRecord;
	return l;
}

直接选择排序

template<class Record>
void SelectSort(Record Array[],int n)
{
	int i,j;
	int min;
	for(i=0;i<n-1;i++)
	{
		min=i;
		for(j=i+1;j<n;j++)
		{
			if(Array[j]<Array[min])
			{
				min=j;
			}
		}
		swap(Array,min,i);
	}
}

堆排序

template<class Record>
void HeapSort(Record Array[], int n)
{
	int i;
	MaxHeap<Record> maxHeap =MaxHeap<Record>(Array,n,n);
	for(i=0;i<n-1;i++)
	{
		maxHeap.RemoveMax();
	}
}

归并排序

template<class Record>
void MergeSort(Record Array[], Record tempArray[],int left,right)
{
	int middle;
	if(left<right)
	{
		middle=(left+right)/2;
		Mergesort(Array,tempArray,left,middle);
		Mergesort(Array,tempArray,middle+1,right);
		Merge(Array,tempArray,left,right,middle);
	}
}

template<class Record>
void Merge(Record Array[], Record tempArray[],int left,int right,int middle)
{
	int i,j,k;
	int l=left;
	int r=right;
	for(i=left;i<=middle;i++)
	{
		tempArray[i]=Array[i];
	}
	for(j=1;j<right-middle;j++)
	{
		tempArray[right-j+1]=Array[j+middle];
	}
	k=left
	while(k<=right)
	{
		if(temp[l]<temp[r])
		{
			Array[k]=temp[l++];
		}
		else
		{
			Array[k]=temp[r--];
		}
		k++;
	}
}

桶排序

template<class Record>
void BucketSort(Record Array[], int n, int max)
{
	int i,j;
	int count[max];
	Record *tempArray = new Record[n];
	for(i=0;i<max;i++)
	{
		count[i]=0;
	}
	for(i=0;i<n;i++)
	{
		count[Array[i]]++;
	}
	for(i=1;i<max;i++)
	{
		count[i]+=count[i-1];
	}
	
	for(i=0;i<n;i++)
	{
		tempArray[i]=Array[i];
	}
	for(i=n-1;i>=0;i--)
	{
		Array[--count[tempArray[i]]]=tempArray[i];
	}
}

基数排序(顺序存储)

template<class Record>
void RadixSort(Record Array[], int n, int d, int r)//n为元素个数，d为排序码位数，r为基数
{
	int i,j,k;
	int count[r];
	Record *tempArray=new Record[n];
	int radix = 1;	
	for(i=0;i<d;i++)
	{
		for(j=0;j<r;j++)
		{
			count[j]=0;
		}
		for(j=0;j<n;j++)
		{
			k=Array[j]/radix%r;
			count[k]++;
		}
		for(j=1;j<r;j++)
		{
			count[j]+=count[j-1];
		}
		for(j=n-1;j>=0;j--)
		{
			k=Array[j]/radix%r
			tempArray[--count[k]]=Array[j];
		}
		for(j=0;j<n;j++)
		{
			Array[j]=tempArray[j];
		}
		radix*=r;
	}
	delete[] tempArray;
	delete[] count;
}

基数排序（链式实现）

class Node
{
	public:
		int key;
		int next;
};
class StaticQueue
{
	public:
		int head;
		int tail;
};
template<class Record>
void RadixSort(Record* Array,int n,int d, int r)
{
	StaticQueue *queue= new StaticQueue[r];
	int i,first=0;
	for(i=0;i<n;i++)
	{
		Array[i].next=i+1;
	}
	Array[n-1].next=-1;
	for(i=0;i<d;i++)
	{
		Distribute(Array,first,i,r,queue);
		Collect(Array,first,r,queue);
	}
	delete[] queue;
	AddrSort(Array,n,first);
}
template<class Record>
void Distribute(Record Array[],int first,int i,int r，StaticQueue* queue)//i表示第i位排序码,r为基数
{
	int j,k,temp;
	int curr=first;
	for(j=0;j<r;j++)
	{
		queue[j].head=-1;
	}
	while(curr!=-1)
	{
		temp=Array[curr].key;
		for(k=0;k<i;k++)
		{
			temp/=r;
		}
		temp=temp%r;
		if(queue[temp].head==-1)
		{
			queue[temp].head=curr;
		}
		else
		{
			Array[queue[temp].tail].next=curr;
		}
		queue[temp].tail=curr;
		curr=Array[curr].next;
	}
}
template<class Record>
void Collect(Record Array[],int first, int r,StaticQueue* queue)
{
	int i;
	for(i=0;i<r-1;i++)
	{
		Array[queue[i].tail].next=queue[i+1].head;
	}
	
}

索引排序

template<class Record>
void IndexSort(Record Array[],int IndexArray[],int n)
{
	int i,j;
	for(i=0;i<n;i++)
	{
		IndexArray[i]=i;
	}
	//插入排序索引
	for(i=1;i<n;i++)
	{
		for(j=i;j>0;j--)
		{
			if(Array[IndexArray[j]]<Array[IndexArray[j-1]])
			{
				swap(IndexArray,j,j-1);
			}
			else 
				break;
		}
	}
	AdjustRecord(Array,IndexArray,n);
}

template<class Record>
void AdjustRecord(Record Array[], int IndexArray[],int n)
{
	int i,j;
	Record tempRecord;
	for(i=0;i<n;i++)
	{
		tempRecord=Array[i];
		j=i;
		while(IndexArray[j]!=i)
		{
			Array[j]=Array[IndexArray[j]];
			IndexArray[j]=j;
			j=IndexArray[j];
		}
		Array[j]=tempRecord;
		IndexArray[j]=j;
	}
}