常见排序算法

直接插入排序

算法思想：

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

有这么一串数组，我们对其进行排序，红色框内为已经有序的序列。

第一次的时候，第一个数据就看做有序的。

具体步骤：

• 将第一个元素标记为已排序
• 遍历没有排序过的元素
• “提取” 元素x
• i = 最后排序过元素的下标到 0 的遍历
• 如果现在排序过的元素 > 提取的元素

​ 将排序过的元素向右移一格

• 否则：插入提取元素

//直接插入排序
void InsertSort(int* a, int sz)
{
	for (int i = 0; i < sz - 1; i++)
	{
        //end是已排序的序列的最后一个元素的下标
        //tmp是已排序序列最后一个元素的 下一个元素 ，即最近一个未排序元素。
		int end = i;
		int tmp = a[end + 1]; 
        //这里不写做 tmp = end + 1 ,是因为end是会变的，但是我们必须记录下当前的未排序元素值
		
        while(end>=0)
		{
			if (a[end] > tmp)
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}

直接插入排序的时间复杂度：

数组原本就是有序的，则时间复杂度最低，所以最好的情况是O(n)

数组完全逆序，则时间复杂度最高，所以最坏的情况是O(n²)

---

希尔排序

学习完直接插入排序，不难发现，如果数组基本有序的情况下，直接插入其实是个很优秀的算法，

因此，就希尔就想到了：如果能在执行直接插入排序前，保证数组基本有序，最后再借助直接插入排序，

就能将时间复杂度降下来。

算法思想：

先进行预排序（直接插入排序前的准备工作，目的是为了使数组基本有序）

再进行直接插入排序。

我们假设一个值：gap = 3。

gap为多少，就会把数组分为多少组，我们将数组分为了gap组，其中每一组的数据间隔都为gap

这样做的目的，是为了让大的数更快地到后面，小的数更快到前面

gap 越大，单次跨越的幅度越大，大数和小数就越快朝各自的方向移动，但是相应地精确度就比较低

gap越大，越不接近有序

gap 越小，单次跨越的幅度越小，大数和小数就越慢朝各自的方向移动，但是相应地精确度就比较高

gap越小，越接近有序

gap == 1 ,所有的数被归为一组，一一对比，其实就是直接插入排序。

end每次移动都在处理不同的分组，当最后一个元素也被处理完后，本轮分组排序就完成了。

因此，我们需要设置循环的终止条件，当 end = n -gap 时， 最后一个元素也就被处理了，本轮结束

end = n - gap，因为元素是从0开始，假设下标为i，实际上 i < n-gap就走了n-gap步。

注：gap = gap/3+1，是为了避免当gap小于3后，如2/3 = 0 ，这样的无效操作，因此给每次得到的gap加上1，

**保证gap至少为1。 **

//希尔排序
void ShellSort(vector<int>& a, size_t n)
{
	int gap = n;
    //gap>1 预排序
    //gap == 1 直接插入排序
	while (gap>1)
	{
        //不一定是除以3，只要不是除以2,都行，分几组都正常。
        // 2/2+1 = 2 ——>死循环
		gap = gap / 3 + 1; //最后一定会有一次gap == 1
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = end + gap;
			while (true)
			{
				if (a[tmp] < a[end])
				{
					swap(a[tmp], a[end]);
					end -= gap;
				}
				else
				{
					break;
				}
			}
		}
	}
}

void ShellSort(int n)
{
    int gap = n;

    while (gap > 1)
    {
        gap = gap / 3 + 1;

        for (int i = 0; i < n - gap; ++i)
        {
            int end = i;
            int tmp = a[end + gap];

            while (end >= 0)
            {
                if (a[end] > tmp)
                {
                    a[end + gap] = a[end];
                    end -= gap;
                }
                else
                    break;
            }

            a[end + gap] = tmp;
        }
    }
}

选择排序

（升序）

算法思想：i = 0 ，遍历，每次从数组里选一个最小的数，放到第 i 个位置，然后++i 。

这样循环下来，就能得到一个有序的数组了。

void SelectSort(vector<int>& a, size_t sz)
{	
	//每次从未排序序列中选出一个最小值min,放到下标为i的位置
	for (int i = 0; i < sz; ++i)
	{
		int min = i;
		for (int j = i + 1; j < sz; ++j)
		{
			if (a[j] < a[min])
			{
				min = j;
			}
		}
		swap(a[min], a[i]);
	}
}

优化：

既然每次都要遍历一遍，与其每次只选出一个最小值，何不每次选出一个最小值、一个最大值？
每次选出一个最大值放在最右边，最小值放在最左边。然后缩小左右区间。

但是这样对于复杂度也没有太明显的提升，

因为原本是n个数选一个，n-1个数选一个，n，n-1，n-2，n-3…

优化后是 n,n-2,n-4,n-6… 还是等差数列，时间复杂度依然是O(N²)，速度稍快了点。

void SelectSort(int* a, int n)
{
	assert(a);
	int begin = 0, end = n - 1;
	while (begin < end)
	{
		int mini = begin, maxi = begin;
		for (int i = begin + 1; i <= end; ++i)
		{
			if (a[i] < a[mini])
				mini = i;

			if (a[i] > a[maxi])
				maxi = i;
		}
		Swap(&a[begin], &a[mini]);

		// 如果begin和maxi重叠，那么要修正一下maxi的位置
		if (begin == maxi)
		{
			maxi = mini;
		}

		Swap(&a[end], &a[maxi]);
		++begin;
		--end;
	}
}

冒泡排序

void BubbleSort(vector<T> nums, int sz)
{
	for (int i = 1; i <= sz - 1; ++i)
	{
		for (int j = 0; j <= sz - i - 1 ; ++j)
		{
			if (nums[j] > nums[j + 1])
			{
				swap(nums[j], nums[j + 1]);
			}
		}
	}

	Print(nums);
}

快速排序

左右指针法

//左右指针法

int PartSort1(vector<int>& a, int left, int right)
{
	//[left,right]
	int keyi = left;
	while (left < right)
	{
		//左边做key，则右边先走，这样才能保证相遇点的值一定小于a[keyi]
		while (left<right && a[right] >= a[keyi]) //右找小
		{
			right--;
		}
		while (left < right && a[left] <= a[keyi]) //左找大
		{
			left++;
		}

		swap(a[left], a[right]);
	}
	//最后要记得把 key 和 相遇位置的值交换一下
	swap(a[keyi], a[left]);
	
	
	//[left,key-1] key [key+1,right]
	//我们现在要得到中间这个位置，它把数组分为两个区间，左小右大
	keyi = left; //或者 keyi = right ,都一样的，因为现在left 和 right 是相遇的。
	return keyi;


}


void QuickSort(vector<int>& a,int begin ,int end)
{
	if (begin >= end)
	{
		return;
	}
	
	int key = PartSort1(a, begin, end);

	QuickSort(a, begin, key);
	QuickSort(a, key + 1, end);
	

}

注：这里条件必须是 >= 和 <=

while (left<right && a[right] >= a[keyi]) //右找小
{
    right--;
}
while (left < right && a[left] <= a[keyi]) //左找大
{
    left++;
}

否则，在 > 和 < 的条件下当出现如图情况时，会出现死循环：

a[right] 没有比 a[keyi]大，停下

a[left] 没有比 a[keyi]小，停下

两数交换。

再次循环：

a[right] 没有比 a[keyi]大，停下

a[left] 没有比 a[keyi]小，停下

两数交换。

…

所以如果是相同的数，其实在哪都是一样的。最好就不要去动他，直接跳过就好，

既然我们要找，就找确确实实比key大或者小的数就好了。

挖坑法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qq5h9Fex-1681093707512)(C:\Users\Z-zp\AppData\Roaming\Typora\typora-user-images\image-20220402172304366.png)\

//挖坑法
int PartSort2(vector<int>& a, int left, int right)
{
	int key = a[left];
	int hole = left;
	while (left < right)
	{
		while (left < right && a[right] >= key)//找小
		{
			right--;
		}
		//找到小了，填到左边的坑里
		a[hole] = a[right];
		hole = right; //新的坑就在右边了

		while (left < right && a[left] <= key) //轮到找大了
		{
			left++;
		}
		//找到大了，填到坑里
		a[hole] = a[left];
		hole = left;
	}
	//最后还会留下一个坑，把被挖出来的那个数填回去
	a[hole] = key;
	
	//区间被分为 ： [begin,hole-1] hole [helo+1,end]
	
	return hole;
}

前后指针法

//前后指针法
template<class T>
int PartSort2(vector<T>& a, int left, int right)
{
	int mid = GetMidIndex(a, left, right);
	swap(a[left], a[mid]);
	int key = left;
	int prev = left;
	int cur = prev + 1;
	while (cur <= right) //去找小往前扔
	{
		/*while (cur <= right && a[cur] >= a[key])
		{
			++cur;
		}
		if (cur > right)
			break;
		swap(a[++prev], a[cur++]);*/

		if (a[cur] < a[key] && ++prev != cur)
		{
			swap(a[prev], a[cur++]);
		}
		//++cur;
	}
	swap(a[prev], a[key]);
	key = prev;
	//[left,key-1] key [key+1,right]
	return key;
}

快速排序优化

通过上述样例，明白了快速排序每次可以确定下来一个数的位置——key

最好的情况：

在最好的情况下，key每次都刚好在中间，将数组区间二分。

这种情况下，其本质就接近完全二叉树的递归过程。

单趟排序一个往左走，一个往右走，直到相遇，这个过程完成了数组的遍历，

所以单趟排序的时间复杂度为O(N)。再者，由于完全二叉树的深度为 log₂N,

因此在最好的情况下，快速排序的时间复杂度接近O(N*logN)

---

但是在最坏的情况下——数组基本有序。

整个算法的时间复杂度直接上升到了O(N²)

---

快速排序既然敢叫快速排序，一定是有过人之处，其实它的优化可以避免掉最坏的情况。

三数取中

会出现最坏的情况，是因为在基本有序的情况下，key很容易取到最小或者最大的数，

只要能够避免取到最小或者最大的数，就不会出现最坏的情况。

我们每次将左边右边还有中间的数相比，取既不是最大，也不是最小的值，作为key。

这样在基本有序的情况下，很大概率每次取到的就都是中间值了，最坏的情况直接变成了最好的情况

**注：**我们在写算法时，一开始仍将左边（右边）的值看做key，再另写一个函数得到中间值后，将中间值与key交换值即可，否则如果key的位置时而在两端，时而在中间，不利于算法的执行。

int GetMidIndex(vector<T>& a, int left, int right)
{
	int mid = (left + right) >> 1;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[left] > a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}

	else  //a[left] > a[mid]
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}

​