八大排序介绍

Posted 2022-02-27 任我驰骋°

八大排序

• 一、排序是什么？
• 二、常见的排序算法
• • 1.插入排序
  • 2.希尔排序
  • 3.选择排序
  • 4.堆排序
  • 5.冒泡排序
  • 6.快速排序
  • • hoare版本
    • 挖坑法
    • 前后指针版本
  • 7.归并排序
  • 8.计数排序
• 三、总结
• • 排序算法复杂度及稳定性分析

一、排序是什么？

  排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。分内部排序和外部排序，若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。反之，若参加排序的记录数量很大，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。内部排序的过程是一个逐步扩大记录的有序序列长度的过程。

二、常见的排序算法

1.插入排序

基本思想：

直接插入排序是一种简单的插入排序法，其基本思想是：

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

直接插入排序：
  当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移。

void InsertSort(int a[], int n)

	for (int i = 1;i < n;i++)
	
		int key = a[i];
		int end = i - 1;
		while (end >= 0 && a[end] > key)
		
			a[end + 1] = a[end];
			end--;
		
		a[end + 1] = key;
	

直接插入排序的特性总结：

1. 元素集合越接近有序，直接插入排序算法的时间效率越高
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)，它是一种稳定的排序算法
4. 稳定性：稳定

2.希尔排序

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

void ShellSort(int a[], int n)

	int gap = n;
	while (gap > 0)
	
		gap = gap / 3 + 1;
		for (int i = gap;i < n;i++)
		
			int end = i - gap;
			int key = a[i];

			while (end >= 0 && key < a[end])
			
				a[end + gap] = a[end];
				end -= gap;
			
			a[end + gap] = key;
		
		gap--;
	

希尔排序的特性总结：

1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就 会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的 希尔排序的时间复杂度都不固定.
4. 稳定性：不稳定.

3.选择排序

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

直接选择排序:
  在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素.
  若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换.
  在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素.

void SelectSort(int *a,int n)

	int begin = 0, end = n - 1;
	while (begin <= end)
	
		int maxPos = begin;
		int minPos = begin;

		int index = begin + 1;
		while (index <= end)
		
			if (a[index] > a[maxPos]) maxPos = index;
			if (a[index] < a[minPos]) minPos = index;
			index++;
		
		if (maxPos != end)
		
			swap(a[maxPos], a[end]);
		
		if (minPos == end)
		
			minPos = maxPos;
		
		if (minPos != begin)
		
			swap(a[minPos], a[begin]);
		
		begin++;
		end--;
	

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

1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：不稳定

4.堆排序

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

void down(int *a, int n, int root)

	int father = root;
	int child = father * 2 + 1;
	while (child < n)
	
		if (child + 1 < n && a[child] < a[child + 1])
		
			child += 1;
		
		if (a[father] < a[child])
		
			swap(a[father], a[child]);
			father = child;
			child = father * 2 + 1;
		
		else return;
	


void HeapSort(int* a, int n)

	int root = (n - 2) / 2;
	for (;root >= 0;root--)
	
		down(a, n, root);
	

	int end = n - 1;
	while (end > 0)
	
		swap(a[0], a[end]);
		down(a,end,0);
		end--;
	

堆排序的特性总

1. 堆排序使用堆来
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(1)
4. 稳定性：不稳定

5.冒泡排序

void BubbleSort(int* a, int n)

	for (int i = 0;i < n - 1;i++)
	
		int ischange = 0;
		for (int j = 0;j < n - i - 1;j++)
		
			if (a[j] > a[j + 1])
			
				swap(a[j], a[j + 1]);
				ischange = 1;
			
		
		if (!ischange) return;
	

冒泡排序的特性总结：

1. 冒泡排序是一种非常容易理解的排序
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：稳定

6.快速排序

  快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

快速排序优化：

1. 三数取中法选key
2. 递归到小的子区间时，可以考虑使用插入排序

// 三数取中法
int GetmiddleIndex(int* a, int left, int right)

    int mid = left + (right - left) / 2;
    if (a[left] < a[right - 1])
    
        if (a[mid] < a[left])
        
            return left;
        
        else if (a[right - 1] < a[mid])
        
            return right - 1;
        
        else
        
            return mid;
        
    
    else
    
        if (a[mid] < a[right - 1])
        
            return right - 1;
        
        else if (a[left] < a[mid])
        
            return left;
        
        else
        
            return mid;
        
    

void QuickSort(int *a,int left,int right)

  if(right-left>1)
  
    //InsertSort(a+left,right-left+1);
    //int mid=PartSort1(a,left,right);
    //int mid=PartSort2(a,left,right);
    int mid=PartSort3(a,left,right);
    QuickSort(a,left,mid);
    QuickSort(a,mid+1,right);
  

  上述为快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像，同学们在写递归框架时可想想二叉树前序遍历规则即可快速写出来，后序只需分析如何按照基准值来对区间中数据进行划分的方式即可。

将区间按照基准值划分为左右两半部分的常见方式有：

hoare版本

int PartSort1(int* a, int left, int right)

    int mid = GetmiddleIndex(a, left, right);
    int begin = left;
    int end = right - 1;
    swap(a[mid], a[end]);
    int key = a[end];
    while (begin < end)
    
        while (begin < end && a[begin] <= key) begin++;
        while (begin < end && a[end] >= key) end--;
        if (begin < end) swap(a[begin],a[end]);
    
    if (begin != right - 1)
    
        swap(a[begin], a[right - 1]);
    
    return begin;

挖坑法

int PartSort2(int* a, int left, int right)

    int begin = left;
    int end = right - 1;
    int mid = GetmiddleIndex(a, left, right);
    swap(a[mid], a[end]);
    int key = a[end];

    while (begin < end)
    
        while (begin < end && a[begin] <= key) begin++;
        if (begin != end)
        
            a[end] = a[begin];
            end--;
        
        while (begin < end && a[end] >= key) end--;
        if (begin != end)
        
            a[begin] = a[end];
            begin++;
        
    
    a[begin] = key;
    return begin;

前后指针版本

int PartSort3(int* a, int left, int right)

    int cur = left;
    int prev = cur - 1;
    int mid = GetmiddleIndex(a, left, right);
    swap(a[mid], a[right-1]);

    int key = a[right - 1];

    while (cur < right)
    
        if (a[cur] < key && ++prev != cur)
            swap(a[cur], a[prev]);
        ++cur;
    

    if (++prev != right - 1)
        swap(a[prev], a[right - 1]);

    return prev;

快速排序的特性总结：

1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
2. 时间复杂度：O(N*logN)
   
3. 空间复杂度：O(logN)
4. 稳定性：不稳定

7.归并排序

基本思想：
  归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 归并排序核心步骤：

void MergeSort(int *a,int l,int r)

  if(l>=r) return ;

  int mid =(l + r)/2;

  MergeSort(a,l,mid),MergeSort(a,mid+1,r);
  int k=0,i=l,j=mid+1,tmp[r-l+1];
  
  while(i<=mid && j<=r)
  
    if(a[i]<=a[j]) tmp[k++]=a[i++];
    else tmp[k++]=a[j++];
  

  while(i<=mid) tmp[k++]=a[i++];

  while(j<=r) tmp[k++]=a[j++];
  
  int m,n;
  for(m=l,n=0;m<=r;m++,n++) a[m]=tmp[n];

归并排序的特性总结：

1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(N)
4. 稳定性：稳定

8.计数排序

思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。 操作步骤：

1. 统计相同元素出现次数
2. 根据统计的结果将序列回收到原来的序列中

void CountSort(int* array, int n)

	int maxValue = array[0];
	int minValue = array[0];
	int i;
	for (i = 0;i < n;i++)
	
		if (array[i] > maxValue)
			maxValue = array[i];

		if (array[i] < minValue)
			minValue = array[i];
	

	int range = maxValue - minValue + 1;

	int* count = (int*)malloc(range * sizeof(int));
	if (count == NULL)
	
		assert(0);
		return;
	

	memset(count, 0, range * sizeof(int));

	for (i = 0;i < n;i++)
	
		count[array[i] - minValue]++;
	

	int index = 0;
	for (i = 0;i < range;i++)
	
		while (count[i])
		
			array[index++] = i + minValue;
			count[i]--;
		
	
	free(count);

计数排序的特性总结：

1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
2. 时间复杂度：O(MAX(N,范围))
3. 空间复杂度：O(范围)
4. 稳定性：稳定

三、总结

排序算法复杂度及稳定性分析