经典排序算法详解

说明

转载请注明出处

常见排序算法的时间和空间复杂度比较。

排序法	平均时间	最差情形	稳定度	额外空间	备注
冒泡排序	O(n2)	O(n2)	稳定	O(1)	n小时较好
选择排序	O(n2)	O(n2)	不稳定	O(1)	n小时较好
插入排序	O(n2)	O(n2)	稳定	O(1)	大部分已排序时较好
希尔排序	O(nlogn)	O(ns) 1<s<2	不稳定	O(1)	s是所选分组
快速排序	O(nlogn)	O(n2)	不稳定	O(nlogn)	n大时较好
归并排序	O(nlogn)	O(nlogn)	稳定	O(1)	n大时较好
堆排序	O(nlogn)	O(nlogn)	不稳定	O(1)	n大时较好
基数排序	O(logRB)	O(logRB)	稳定	O(n)	B是真数(0-9)，R是基数(个十百)

附上各个排序算法的代码： 采用c++语言

冒泡排序

算法思想：

通过两个 for 循环实现冒泡排序的全过程，外层 for 循环决定冒泡排序的趟数，内层 for 循环决定每趟所进行两两比较的次数。

C++代码：

void bobblesort(vector<int> &nums)
{
	for (int i = 0; i < nums.size(); i++){
		bool swapFlag = false;
		for (int j = i + 1; j < nums.size(); j++){
			if (nums[j - 1] > nums[j]){
				swapFlag = true;
				nums[j - 1] = nums[j - 1] ^ nums[j];
				nums[j] = nums[j - 1] ^ nums[j];
				nums[j - 1] = nums[j - 1] ^ nums[j];
			}
			if (!swapFlag)
				break;
		}
	}
	return;
}

选择排序

算法思想：

选择排序的基本思想：
每一趟在n-i+1（i=1,2,3…,n-1）个记录中选取关键字最小的记录与第i个记录交换，并作为有序序列中的第i个记录。
例如：
待排序列： 43，65，4，23，6，98，2，65，7，79
第一趟： 2，65，4，23，6，98，43，65，7，79
第二趟： 2，4，65，23，6，98，43，65，7，79
第三趟： 2，4，6，23，65，98，43，65，7，79
第四趟： 2，4，6，7，43，65，98，65，23，79
第五趟： 2，4，6，7，23，65，98，65，43，79
第六趟： 2，4，6，7，23，43，98，65，65，79
第七趟： 2，4，6，7，23，43，65，98，65，79
第八趟： 2，4，6，7，23，43，65，65，98，79
第九趟： 2，4，6，7，23，43，65，65，79，98

C++代码：

void selectsort(vector<int>& nums){
	for (int i = 0; i < nums.size(); i++){
		int minindex = i;
		for (int j = i + 1; j < nums.size(); j++){
			if (nums[j] < nums[minindex])   minindex = j;
		}
		if (i < minindex){
			nums[i] = nums[i] ^ nums[minindex];
			nums[minindex] = nums[i] ^ nums[minindex];
			nums[i] = nums[i] ^ nums[minindex];
		}
	}
}

插入排序

算法思想：

插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。刚开始这个小序列只包含第一个元素，事件复杂度O(n2)。比较是从这个小序列的末尾开始的。想要插入的元素和小序列的最大者开始比起，如果比它大则直接插在其后面，否则一直往前找它该插入的位置。如果遇见了一个和插入元素相等的，则把插入元素放在这个相等元素的后面。所以相等元素间的顺序没有改变，是稳定的。

C++代码：

void insertsort(vector<int>& nums){
	for (int i = 1; i < nums.size(); i++){
		int index = i-1;
		int temp = nums[i];
		while(index >= 0 && nums[index] > temp){
			nums[index + 1] = nums[index];
			index--;
		}
		nums[index + 1] = temp;
	}
}

希尔排序

算法思想：

希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小，插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比o(n^2)好一些。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。

C++代码：

void shellsort(vector<int>& nums) {
	for (int d = nums.size() / 2; d > 0; d /= 2){
		for (int i = 0; i < d; i++){
			for (int j = i + d; j < nums.size(); j += d){
			    int index = j - d;
				int temp = nums[j];
				while (index >= 0 && nums[index] > temp){
					nums[index + d] = nums[index];
					index -= d;
				}
				nums[index + d] = temp;
			}
		}
	}
}

快速排序

算法思想：

快速排序有两个方向，左边的i下标一直往右走，当a[i] <= a[center_index]，其中center_index是中枢元素的数组下标，一般取为数组第0个元素。而右边的j下标一直往左走，当a[j] > a[center_index]。如果i和j都走不动了，i <= j, 交换a[i]和a[j],重复上面的过程，直到i>j。 交换a[j]和a[center_index]，完成一趟快速排序。在中枢元素和a[j]交换的时候，很有可能把前面的元素的稳定性打乱，比如序列为 5 3 3 4 3 8 9 10 11， 现在中枢元素5和3(第5个元素，下标从1开始计)交换就会把元素3的稳定性打乱，所以快速排序是一个不稳定的排序算法，不稳定发生在中枢元素和a[j]交换的时刻。

C++代码：

void quicksortutil(vector<int>& nums, int start, int end){	
	if(start > end) 
		return;
	int key = nums[start]; //基准
	int i = start;
	int j = end;
	while (i < j)
	{
		while (nums[j] >= key && j >i)
			j--;
		while (nums[i] <= key && j > i)
			i++;
		if (i < j){
			nums[i] = nums[i] ^ nums[j];
			nums[j] = nums[i] ^ nums[j];
			nums[i] = nums[i] ^ nums[j];
		}
	}
	nums[start] = nums[i];
	nums[i] = key;
	quicksortutil(nums,start,i-1);
	quicksortutil(nums, i+1,end);
}
void quicksort(vector<int>& nums){
	return quicksortutil(nums, 0, nums.size()-1);
}

归并排序

算法思想：

归并排序是把序列递归地分成短序列，递归出口是短序列只有1个元素(认为直接有序)或者2个序列(1次比较和交换),然后把各个有序的段序列合并成一个有序的长序列，不断合并直到原序列全部排好序。可以发现，在1个或2个元素时，1个元素不会交换，2个元素如果大小相等也没有人故意交换，这不会破坏稳定性。那么，在短的有序序列合并的过程中，稳定是是否受到破坏？没有，合并过程中我们可以保证如果两个当前元素相等时，我们把处在前面的序列的元素保存在结果序列的前面，这样就保证了稳定性。所以，归并排序也是稳定的排序算法。

代码：

hello world

堆排序

算法思想：

堆排序的基本思想是：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。

JAVA代码：

    void deapsort(int[] nums){
          for(int i = nums.length -1 ; i >= 0 ; i-- ){
              mindeap(nums,i);
              int temp = nums[0];
              nums[0] = nums[i];
              nums[i] = temp;
          }
    }
    void mindeap(int[] nums, int index)
    {
        for(int i = index; i>=1 ; i--){
            if(nums[i] < nums[(int) (Math.ceil(i/2.0)-1)]){
                int temp =nums[i];
                nums[i]=  nums[(int) (Math.ceil(i/2.0)-1)];
                nums[(int) (Math.ceil(i/2.0)-1)] = temp;
            }
        }
    }

基数排序

算法思想：

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序，最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以其是稳定的排序算法。

代码：

hello world

main函数

C++

int main()
{
	vector<int> nums;
	nums.push_back(1);
	nums.push_back(3);
	nums.push_back(1);
	nums.push_back(8);
	nums.push_back(7);
	nums.push_back(5);
	for (int i = 0; i < nums.size(); i++)
	{
		cout << nums[i] << " ";
	}
	cout << endl;

    //bobblesort(nums);
	//selectsort(nums);
	//insertsort(nums);
	//shellsort(nums);
	quicksort(nums);
	for (int i = 0; i < nums.size(); i++){
		cout << nums[i] <<" ";
	}
	return 0;
}

ps: 新版的富文本编辑器真不错。