排序算法总结

//选择排序
void SelectSort(int* data,int length)
{
	if(data==NULL || length<=0)
		return;
	for(int i=0;i<length-1;i++)
	{
		int min=i;
		for(int j=i+1;j<length;j++)
		{
			if(data[j]<data[min])
				min=j;
		}
		if(i!=min)
			Swap(data[i],data[min]);
	}
}

//插入排序
void InsertSort(int* data,int length)
{
	if(data==NULL || length<=0)
		return;
	for(int i=1;i<length;i++)
	{
		int temp=data[i];
		for(int j=i-1;j>=0;j--)
		{
			if(data[j]>temp)
			{
				data[j+1]=data[j];
			}
			else
				break;
				
		}
		data[j+1]=temp;//for循环内最后j--，所以j要加1才可以
		
	}
}
//冒泡排序
void BubbleSort(int* data,int length)
{
	if(data==NULL || length<=0)
		return;
	for(int i=0;i<length-1;i++)
	{
		for(int j=i;j<length-i-1;j++)
		{
			if(data[j]>data[j+1])
				Swap(data[j],data[j+1]);
		}
	}
}

//归并排序
void Merge(int* data,int start,int mid,int end )
{
	int n1=mid-start+1;
	int n2=end-mid;
	int *L=new int[n1+1];
	int *R=new int[n2+1];
	int i=0,j=0,k=0;
	for(;i<n1;i++)
		L[i]=data[start+i];
	for(;j<n2;j++)
		R[j]=data[mid+1+j];
	
	L[n1]=10000000;
	R[n2]=10000000;
	for(int i=0,j=0,k=start;k<=end;k++)
	{
		if(L[i]>R[j])
		{
			data[k]=R[j];
			j++
		}
		else
		{
			data[k]=L[i];
			i++;
		}
	}
	
	delete []L;
	delete []R;
}

void MergeSort(int* data,int start,int end)
{
	if(data==NULL || start<0||start>end)
		return;
	int mid=(start+end)/2;
	MergeSort(data,start,mid);
	MergeSort(data,mid+1,end);
	Merge(data,start,mid,end);
	
}
//快速排序
void QuickSort(int* data,int length)
{
	Sort(data,0,length-1);
}

void Sort(int* data,int low,int high)
{
	if(data==NULL || low>=high)
		return;
	int index=data[low];
	int i=low;
	int j=high;
	while(i<j)
	{
		while(i<j &&data[j]>index)
			j--;
		if(i<j)
			data[i++]=data[j];
		while(i<j && data[i]<index)
			i++;
		if(i<j)
			data[j--]=data[i];
	}
	data[i]=index;
	
	Sort(data,low,i-1);
	Sort(data,i+1,high);
}
//希尔排序
//首先将待排序的元素分成多个子序列，使得每个子序列的元素个数较少，对各个子序列分别进行直接插入排序，
//待整个待排序序列基本有序之后，再对所有的元素进行一次直接插入排序
void ShellSort(int* data,int length)
{
	if(data==NULL || low>=high)
		return;
	for(int h=length/2;h>0;h=h/2)
	{
		for(int i=h;i<length;i++)
		{
			int temp=data[i];
			for(int j=i-h;j>=0;j=j-h)
			{
				if(data[j]>temp)
					daat[j+h]=data[j];
				else
					break;
			}
			data[j+h]=temp;
		}
	}
	
	
}

//堆排序
//调整为最大堆
void HeapAdjust(int* data, int length, int i)
{
	int left=2*i;
	int right=2*i+1;
	int largest=i;
	while(left<length || right<length)
	{
		
		if(left<length && data[left]>data[largest])
		{
			largest=left;
		}
		if(right<length && data[right]>data[largest])
		{
			largest=right;
		}
		
		if(i!=largest)
		{
			Swap(data[i],data[largest]);
			i=largest;
			left=2*i;
			right=2*i+1;			
		}
		else
			break;	
	}

}

void HeapSort(int *data,int length)
{
	if(data==NULL || length<=0)
		return;
	for (int i = length/2 - 1; i >= 0; i--)
		HeapAdjust(data,length,i);//将一个无序序列调整为最大堆，从第一个非叶子结点开始调整
	for (int j = length - 1; j>0; --j)
	{
		Swap(data[j],data[0]);//首先将堆顶的元素与最后一个元素交换/然后将堆顶的元素与倒数第二个元素交换/依次进行
		HeapAdjust(data,j-1,0);//最大的元素放在最末尾，将剩下的元素调整为最大堆/倒数第二大元素放在倒数第二个位置，将剩下的元素调整为最大堆/依次进行下去
	}

}