C:排序算法

目录

插入排序:

希尔排序:

选择排序:

堆排序:

---

插入排序:

        把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为 止，得到一个新的有序序列 。

       下标i从1开始,i之前的序列是有序序列,i当前的位置是待排序的元素,如果该元素比前一个元素小,把该元素放入tmp:

 然后将a[j-1]赋值给a[j]:

j开始遍历i之前的有序序列,当j>0&&a[ j-1 ]<tmp时,j的位置放入tmp:

此时tmp已经排好序,i++,对下一个元素进行排序:

 循环下去,直到 i 排好数组的最后一个元素.

void InsertSort(int* a, int n)
{
	int  j, tmp;
	for (int i = 1; i < n; i++)
	{
		j = i;//
		if (a[j] < a[j-1])
		{
			tmp = a[j];
			do
			{
				a[j] = a[j-1];
				j--;//当j减到0,说明此时的0位置已经来到了j+1位置
				//下方的希尔排序也是,当j-gap之后,如果j下一个位置的下标小于0,说明这是我这组需要移动的最后一个元素

			} while (j > 0 && tmp < a[j-1]);
			a[j] = tmp;
    	}
			
	}
}

时间复杂度是O(n^2),但是当数组接近有序时,其时间复杂度会根据有序程度而降低.

空间复杂度是O(1)

稳定:从while循环的判断条件就可以看出来,当tmp=a[ j-1] 时,循环会停止,即tmp放入了与它值相等的元素的后一个位置.

希尔排序:

希尔排序法又称缩小增量法。希尔排序法的基本思想是： 先选定一个整数，把待排序文件中所有记录分成个 组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工 作。当到达 =1 时，所有记录在统一组内排好序 。

gap=5 到 gap=2:

 在gap==1之前,数组已经接近有序:

 gap=1时,就相当于直接对数组进行插入排序,在gap=1之前,已经对数组进行了预排序,所以插入排序的时间复杂度会降低很多:

void ShellSort(int* a, int size)
{
	int gap = size;
	while (gap > 1)
	{
		gap /= 2;
	
		
			for (int i = gap; i < size; i ++)
			{
				int swap = i;
				int tmp = a[swap];
				if (a[swap] < a[swap - gap])
				{ 
					do
					{
						a[swap] = a[swap - gap];
						swap -= gap;
					} while (swap - gap >= 0 && a[swap - gap] > tmp);
					a[swap] = tmp;
				}
			}
	}
	
	
}

希尔排序的特性总结：

1. 希尔排序是对直接插入排序的优化

2. 当 gap > 1 时都是预排序，目的是让数组更接近于有序。当 gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。

3. 希尔排序的时间复杂度不好计算，因为 gap 的取值方法很多，导致很难去计算，因此在好些树中给出的 希尔排序的时间复杂度都不固定:

 

 4.稳定性:不稳定.

选择排序:

        每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的 数据元素排完 。

void SelectSort(int* a, int n)
{
	int left = 0;
	int right = n - 1;
	int mini = 0;
	int maxi = n-1;
	//left表示0~left已经有序,并且是升序
	//i从left开始遍历数组,当遇到比a[left],mini也从left开始,当遇到a[i]<a[mini]的时候,mini记录该数的下标,这样就可以在
	//无序区间中找到最小值,那么a[left]与a[mini]进行交换
	//同样的i遍历数组的时候遇到比a[maxi]更大的数时,maxi记录该数的下标,当遍历完无序区间后,a[maxi]的值就是无序区间中最大的值
	//遍历一遍结束后,left++,right--,minx=left,maxi=right,无序区间缩小,有序区间增加
	//当left>=right时,数组排序完成
	while (left < right)
	{
		for (int i = left; i <= right; i++)
		{
			if (a[i] < a[mini])
			{
				mini = i;
			}
			if (a[i] > a[maxi])
			{
				maxi = i;
			}
		}
		Swap(&a[left], &a[mini]);
		//选择排序需要注意的问题
		//当maxi=left时,left先与mini交换,left在与right交换,所以最后交换的结果是minx与maxi之间的交换,所以需要对特殊情况进行处理
		if (maxi == left)
		{
			maxi = mini;
		}
		Swap(&a[right], &a[maxi]);
		left++;
		right--;
		mini = left;
		maxi = right;
	}
	

}

直接选择排序的特性总结：

1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用

2. 时间复杂度： O(N^2)

3. 空间复杂度： O(1)

4. 稳定性：不稳定

堆排序:

堆排序 (Heapsort) 是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是 通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

        堆是一种数据结构,该结构的底层用动态数组实现

//向下调整
//建大堆

void Down(int* a, int size,int parent)
{
	int child = parent * 2 + 1;
	
	
		while (child < size)
		{

			if (child + 1 < size && a[child + 1] > a[child])
			{
				child++;
			}
			if (a[parent] < a[child])
			{
				Swap(&a[parent], &a[child]);
				parent = child;
				child = child * 2 + 1;
				
			}
			else
			{
				break;
			}
		}
}

void HeapSort(int* a, int n)
{
	//先建堆
	//向下调整
	for (int i = (n - 2) / 2; i >= 0; i--)
	{
		Down(a, n, i);
	}
	//排序
	while (n--)
	{
		Swap(&a[0], &a[n]);
		Down(a, n, 0);
	 }
}