常见排序总结

/*
选择排序
每一趟选取第i个关键字，与剩下的n-i关键字进行比较，找出最大的值与刚开始选择的i下标对应的值交换
第一趟: 0 , 1~n-1
第二趟:1, 2~n-1
.....
应用场景
  最好最坏情况时间复杂度都是O(n^2) 空间复杂度为O(1)
  最坏情况：对相对有序的一组数据排序
  不稳定 由其交换引起的
  适用于数量不大并且交换次数少的情况下
*/

void Select_Sort(int *arr,int len)
{

	if(arr == NULL || len < 0)
		return ;
	int i,j;
	int minIndex;
	for(i = 0;i < len -1 ;++i)
	{
		minIndex = i;
		for( j = i+1 ;j < len - 1;++j )
		{
			if(arr[j] < arr[minIndex])
			{
				minIndex = j;
			}
		}

		if(i != minIndex)
		{
			int tmp = arr[minIndex];
			arr[minIndex] = arr[i];
			arr[i] = tmp;
		}
	}
}

/*
冒泡排序
每趟两个相邻的数据比较，如果前者大于后者就交换位置；每趟最后一个元素都是本趟元素里最大的那个
所以在每趟的比较中，上一趟的最后一个元素不再参与排序

本代码是升序排列 
  给出的数字序列也是相对于升序 那么交换次数少 最好情况下时间复杂度O(n)
  给出的数字序列是完全降序  那么交换次数duo 最坏情况下时间复杂度O(n^2)
*/

void Bulle_Sort(int *arr,int len)
{
	if(arr == NULL || len < 0)
		return ;

	int i ,j;
	for( i = 0 ; i < len-1 ;++i)
	{
		for(j = 0;j < len -i-1 ;++j)
		{
			if(arr[j] > arr[j+1])
			{
				int tmp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = tmp;
			}
		}
	}
}

/*
直接插入排序
每趟选定一个标兵位，标兵位开始往前遍历 找出第一个比标兵位小的位置
那么这个位置的后面就是该标兵存放的位置

应用场景
给出的数字序列基本有序 最好情况下 时间复杂度O(n)
给出的数字基本无序 最坏情况下 时间复杂度O(n^2)
空间复杂度为O(1)
如果有少量或者大量数据都可以采用
*/

void Insert_Sort(int *arr,int len)
{
	if(arr == NULL || len < 0)
		return ;
	int tmp = 0;
	int j;
	for(int i = 1;i < len - 1; i++)
	{
		tmp = arr[i];
		for(j = i-1;j >= 0;j--)
		{
			if(arr[j] > tmp)
			{
				arr[j+1] = arr[j];
			}
			else
			{
				break;
			}
		}
		arr[j+1] = tmp;
	}
}

/*
归并排序 采用二路归并法
开辟另一个与旧数组空间大小的数组
两个有序的归并段 依次从头开始比较 小的先放入到新开辟的数组中 在继续往后比较归并 直至归并为一个归并段
每一次归并归并段的增量为上一次的二倍
时间复杂度 一次归并O(logn),整体归并时间复杂度O(nlogn)
空间复杂度 O(n)
*/

void Merge(int *arr,int len ,int gap)
{
	int low1 = 0;
	int high1 = low1+gap-1;

	int low2 = high1+1;
	int high2 = low2+gap-1 < len ? low2+gap-1:len-1;

	int *brr = new int[len];
	if(brr == NULL) return ;
	int i = 0;
	while(low2 < len)//保证第二个归并段至少有一个数字
	{
		while(low1 <= high1 && low2 <= high2)
		{
			if(arr[low1]<=arr[low2])
			{
				brr[i++] = arr[low1++];
			}
			else
			{
				brr[i++] = arr[low2++];
			}
		}

		//两个归并段比完之后还有可能某个归并段剩余数据
		while(low1 <= high1)
		{
			brr[i++] = arr[low1++];
		}
		while(low2 <= high2)
		{
			brr[i++] = arr[low2++];
		}

		low1 = high2+1;
		high1 = low1+gap-1;

		low2 = high1+1;
		high2 = low2+gap-1<len?low2+gap-1:len-1;
	}

	while(low1 < len)//不足两个归并段
	{
		brr[i++] = arr[low1++];
	}

	for(i = 0 ;i < len ;++i)
	{
		arr[i] = brr[i];
	}
	delete []brr;
}
void Merge_Sort(int *arr,int len)
{
	if(arr == NULL ||len < 0)
		return ;
	for(int i = 1;i < len ;i = i*2)
	{
		Merge(arr,len,i);
	}
}

/*
堆排序
将数组中的值虚拟的建立成一个根堆
一次调整堆从上往下调整 时间复杂度为O(logn)
第一次建堆从下往上 建堆时间复杂度为O(n*lon)
堆排序的时间复杂度为 O(n*lon)
空间复杂度为O(1)
应用场景  
  在不要求完全有序的情况下得到数据中最大或者最小的部分数据 可以选择堆排序
*/

void Adjust(int *arr,int start,int end)
{
	//将开始的值保存在临时量中
	int tmp = arr[start];
	

	for(int i = 2*start+1;i < end ;i = 2*start+1)
	{
		//i+1 < end保证了有右孩子的存在  每次还需将i的左右孩子进行比较 i每次的落脚点都是左孩子处
		if((i+1<=end) && arr[i] < arr[i+1])
		{
			i++;//i下标始终对应左右孩子中的最大值
		}
		//判断父节点的值与左右孩子中最大值的大小关系 如果小于最大值 则两个值进行交换
		//交换后需要比较i所在节点它的左右孩子与其当前值的大小关系
		if( tmp < arr[i])
		{
			arr[start] = arr[i];
			start = i;
		}
		else
		{
		//左右孩子值都小于父节点的值
			break;
		}
	}
	arr[start] = tmp;
}
void Heap_Sort(int *arr,int len)
{
	if(arr == NULL || len < 0)
		return ;
	int i;
	//len-1是最后一个元素 根据最后一个元素下标推其父亲节点下标  i-1/2 所以本题中即为len-1-1/2
	for( i = (len-1-1)/2;i>=0;--i)
	{
		Adjust(arr,i,len-1);
	}

	int tmp = 0;
	for( i = 0;i < len -1 ;++i)
	{
		tmp = arr[0];
		arr[0] = arr[len-1-i];
		arr[len-1-i] = tmp;
		Adjust(arr,0,len-1-i-1);
		//由于最后一个已经是有序了的 再一次调整时他就不参与了
	//即就是每一次的交换后最后一个元素都不参与调整过程
	}
	
}