常见排序算法（一）：冒泡，插入，选择，快速排序

一，冒泡排序

首先最常见的排序算法估计就是冒泡排序了。原理也非常的简单，看下面的代码：

class solution
{
public:
	void bubblesort(vector<int>& array)
	{
		int len = array.size();
		for (int i = 0;i < len-1;i++)
		{
			for (int j = 0;j < len - 1 - i;j++)
			{
				if (array[j] > array[j + 1])//升序
					swap(array[j], array[j + 1]);
			}
		}
	}
};

首先拿第一个元素和后面的所有一个个比较，如果比后面的大就交换，所以始终会保证 第一个元素是最小的，然后再从第二个第三个，以此类推，swap方法表示交换两个数字 的值。

为了提高效率，其实当后面序列顺序已经排好的时候可以终止循环了：

void bubblesort(vector<int>& array)
	{
		int count = array.size() - 1;
		bool flag = true;
		while (flag)
		{
			flag = false;
			for (int i = 0;i < count;i++)
			{
				if (array[i] > array[i + 1])
				{
					swap(array[i], array[i + 1]);
					flag = true;
				}
			}
			count--;
		}

当后面的都已经排序好的时候其实是不需要交换的，所以就会终止循环。但总之内核思想是不变的。

现在我们来看看用递归实现冒泡排序：

void bubblesort(vector<int>& array,int len)
	{
		//这里len第一次传值的时候是数组的长度
		if (len == 1)
			return;
		if (array.size() == 0)
			return;
		//逐渐减少len 的值 ，直到len==1
		for (int i = 0;i < len - 1;i++)
		{
			if (array[i] > array[i + 1])
				swap(array[i], array[i + 1]);
		}
		bubblesort(array, len - 1);
	}

二，选择排序

选择排序和冒泡排序很相似，选择排序是默认前面都是排好序的，然后从后面选择最小的数与排好序的数后面。首先第一轮排序从第一个数后面的序列中找到最小的数与第一个数交换，第二轮循环的时候默认第一个元素是已经 排序好的，然后从剩下的找出最小的放到数组的第二个位置，第三轮循环的时候默认前 两个都是已经排序好的，然后再从剩下的选择一个最小的放到数组的第三个位置，以此类推。

代码如下：

void selectsort(vector<int>& array)
	{
        //升序
		for (int i = 0;i < array.size();i++)
		{
			int index = i;
			for (int j = i + 1;j < array.size();j++)
			{
				if (array[index] > array[j])
					index = j;
			}
			if (i != index)
				swap(array[i], array[index]);
		}
	}

下面介绍递归的写法：

void selectsort(vector<int>& array,int i)
	{
        //i初始为0
		if (i == array.size())
			return;
		int index = i,j=0;
		for (j = i + 1;j < array.size();j++)
		{
			if (array[index] > array[j])
				index = j;
		}
		if (i != index)
			swap(array[i], array[index]);
		selectsort(array, i + 1);
	}

三，插入排序

插入排序的原理就是从第二个元素开始从后面逐个读取插入到前面 适合的位置，就相当于打扑克的时候每获取一张牌的时候就插入到合适的位置 一样。

插入排序可以分为两种，一种是直接插入还一种是二分法插入，直接插入的原理 比较简单，就是往前逐个查找直到找到合适的位置然后插入，二分法插入是先折半查 找，找到合适的位置然后再插入。

直接插入代码：

void insertsort(vector<int>& array)
	{
		if (array.size() < 2)
			return;
		for (int i = 1;i < array.size();i++)
		{
			int p = i, temp = array[i];
			for (int j = i - 1;j >= 0;j--)
			{
				if (array[j] > temp)
				{
					array[j + 1] = array[j];//往后移
					p--;
				}
				else//如果没有比temp 大的数了，说明p指向的就是这个值合适的位置了，就break；
					break;
			}
			array[p] = temp;//插入
		}

二分插入代码：

void insertSort(vector<int>& array)
	{
		int len = array.size();
		for (int i = 1;i < array.size();i++)
		{
			int left = 0, right = i - 1,key=array[i];
			//二分法 找出最适位置
			while (left <= right)
			{
				int mid = (right + left) / 2;
				if (array[mid] > key)
					right = mid - 1;
				else
					left = mid + 1;
			}
			for (int j = i;j > left;j--)
				array[j] = array[j - 1];
			array[left] = key;
		}
	}

如果数据很大的情况下，二分法插入排序明显比直接插入效率要高。

四，快速排序

我之前写过：

 初学--c语言快速排序_m0_63901241的博客-CSDN博客

但我还是提一嘴，快速排序原理是首先要找到一个基准数，把小于基准数的值放到他前面，大于基准数的值放到 他的右边，然后再以此方法对这两部分数据分别进行快速排序。

与之前不同写法的代码（C++）：

void quicksort(vector<int>& array, int left, int right)
	{
		//left 和right 分别是array 两端
		if (left < right)
		{
			int key = array[left];//key 便是基准数
			int i = left;
			for (int j = left + 1;j <= right;j++)
			{
				if (array[j] < key)
					swap(array[j], array[++i]);
			}
			swap(array[i], array[left]);
			//递归
			quicksort(array, left, i - 1);
			quicksort(array, i + 1, right);
		}
	}

未完待续......