C++后端面试|笔试基础(1):几大排序算法

面试和笔试中常常会遇到排序算法的提问和面试；
这是基础必须打牢

0. 总结

（该图表来自于「yj_coder」）

1. 插入排序(Straight Insertion Sort)

• 基本思想

将一个数据插入到已排序好的有序表中，从而得到一个新的、总长度增加1的有序表。
即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

要点：设立哨兵，作为临时存储和判断数组边界之用。

2. 希尔排序（Shell`s Sort）

3. 选择排序（Simple Selection Sort）

简单来讲，选择排序的思路就是：

• 从未排序的序列中，找出一个最大或者最小的数据，插入到序列首或尾，以实现递增序列或者最小序列排序；

下面代码的实现思路就是：
从已有队列中，选择一个最小的，和最前面的数据交换（插入），最后会排列成一个递增的序列；

// 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

// 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

// 重复第二步，直到所有元素均排序完毕。

void xuanzesort(vector<int> &a)
{

    for (int i = 0; i < a.size() - 1;i++)
    {
        int min = i;
        for (int j = i + 1; j < a.size();j++)
        {
            if(a[j]<min)
                min = j;
        }

        swap(a[min], a[i]);

    }
}

4. 堆排序（Heap Sort）

5. 冒泡排序（Bubble Sort）

20200725更新，面试手撕冒泡排序；既然考到了，特地来更新下：

void Bubble_Sort( ElementType A[], int N )
{ 
	for ( P=N-1; P>=0; P-- )
	{
		flag = 0;
		for( i=0; i<P; i++ ) 
		{ /* 一趟冒泡 */
			if ( A[i] > A[i+1] ) 
			{
				Swap(A[i], A[i+1]);
				flag = 1; /*  标识发生了交换 */
			}
		}
	}
	if ( flag==0 ) 
		break; /* 全程无交换 */
	}
}

6. 快速排序（Quick Sort）

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
// void quickSort(int s[], int l, int r);
void swapd(int &a,int &b) //拷贝和指针 引用
{
	int temp= a;
	a = b;
	b = temp;
}
void quickSort(int arr[], int low, int high); //访问数组都是访问 不是拷贝
void quickSortv(vector<int> &ss, int low, int high)
{
	if (high <= low) return;
    int i = low;
    int j = high+1 ;
    int key = ss[low];//基准为low
    while (true)
    {
        /*从左向右找比key大的值*/
        while (ss[++i] < key)
        {
            if (i == high){
                break;
            }
        }
        /*从右向左找比key小的值*/
        while (ss[--j] > key)
        {
            if (j == low){
                break;
            }
        }
        if (i >= j) break;
        /*交换i,j对应的值*/
		int temp = ss[i];
		ss[i] = ss[j];
		ss[j] = temp;
		//swapd(ss[i], ss[j]);
	}
    /*中枢值与j对应值交换*/
	//swapd(ss[low], ss[j]);
	int temp = ss[low];
	ss[low] = ss[j];
	ss[j] = temp;

    quickSortv(ss, low, j - 1);
    quickSortv(ss, j + 1, high);
}

int main()
{
	int s[] = {1, 23, 4, 5, 67, 8, 9, 32134, 13, 2, 312, 24};
	vector<int> ss = {1, 23, 4, 5, 67, 8, 9, 32134, 13, 2, 312, 24};
	quickSort(s, 0, 11);
    quickSortv(ss, 0, 11);
	for (int i = 0; i < 12;i++)
	{
		cout << s[i]<<" ";
	}
	cout << endl;
}
void quickSort(int arr[], int low, int high)
{
	if (high <= low) return;
    int i = low;
    int j = high + 1;
    int key = arr[low];
    while (true)
    {
        /*从左向右找比key大的值*/
        while (arr[++i] < key)
        {
            if (i == high){
                break;
            }
        }
        /*从右向左找比key小的值*/
        while (arr[--j] > key)
        {
            if (j == low){
                break;
            }
        }
        if (i >= j) break;
        /*交换i,j对应的值*/
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    /*中枢值与j对应值交换*/
    int temp = arr[low];
    arr[low] = arr[j];
    arr[j] = temp;
    quickSort(arr, low, j - 1);
    quickSort(arr, j + 1, high);
	// if (l< r)
	// {      
	// 	int i = l, j = r, x = s[l];
	// 	while (i < j)
	// 	{
	// 		while(i < j && s[j]>= x) // 从右向左找第一个小于x的数
	// 			j--; 
	// 		if(i < j)
	// 			s[i++] = s[j];
	// 		while(i < j && s[i]< x) // 从左向右找第一个大于等于x的数
	// 			i++; 
	// 		if(i < j)
	// 			s[j--] = s[i];
	// 	}
	// 	s[i] = x;
	// 	quickSort(s, l, i - 1); // 递归调用
	// 	quickSort(s, i + 1, r);
	// }
}