排序算法全解析-优快云博客

排序的分类

内部排序与外部排序

按照排序过程设计的存储器的不同分为内部排序与外部排序。内部排序完全在内存中进行，适合数据量不太大的数据元素的排序。外部排序需要访问外部存储器，待排序的数据元素非常多，以至于它们必须存储在外部存储器上。

稳定排序与不稳定排序

如果对任意一组数据元素序列，使用排序算法排序后，相同关键字之间的前后位置关系在排序前后保持一致，则该排序算法是稳定的。

内排序的方法

内排序的过程是一个逐步扩大记录的有序序列长度的过程。基于不同的“扩大”方法，内排序方法可分为插入类、交换类、选择类、归并类。

插入类排序

即在一个已经有序的序列中，插入一个新的记录。这类排序有：希尔排序、直接插入排序、折半插入排序。

①希尔排序

希尔排序（shell
sort）这个排序方法又称为缩小增量排序，是1959年D·L·Shell提出来的。该方法的基本思想是：设待排序元素序列有n个元素，首先取一个整数increment（小于n）作为间隔将全部元素分为increment个子序列，所有距离为increment的元素放在同一个子序列中，在每一个子序列中分别实行直接插入排序。然后缩小间隔increment，重复上述子序列划分和排序工作。直到最后取increment=1，将所有元素放在同一个子序列中排序为止。
由于开始时，increment的取值较大，每个子序列中的元素较少，排序速度较快，到排序后期increment取值逐渐变小，子序列中元素个数逐渐增多，但由于前面工作的基础，大多数元素已经基本有序，所以排序速度仍然很快。

希尔排序

交换类排序

该类方法的核心是“交换”，即每趟排序，都是通过一系列的“交换”动作完成的。这类排序有：冒泡排序、快速排序。

快速排序

在这里插入图片描述

选择类排序

该方法的核心是“选择”，即每趟排序都选出一个最小（或最大）的记录，把它和序列中的第一个（或最后一个）记录交换，这样最小（或最大）的记录到位。这类排序有：选择排序、堆排序。

e.g.有一组记录（46,77,55,38,41,85），用堆排序建立的初始堆为：（85,77,55,38,41,46）
（这边有一个堆排序介绍图文比较清楚 https://www.cnblogs.com/chengxiao/p/6129630.html ）

归并类排序

所谓归并，就是将两个或两个以上的有序序列合并成一个新的有序序列。这类排序有：（二路）归并排序。

归并排序

在这里插入图片描述

快速排序与归并排序比较
快速排序和归并排序都需要递归。
快速排序是以某一元素为界，比它大的和比它小的各为一类。
归并排序是两个或两个以上的有序序列合并成一个新的有序序列。

基数类排序（桶排序）

此类方法较为特别，是基于多关键字排序的思想，把一个逻辑关键字拆分成多个关键字，如一副扑克牌，按照基数排序思想可以先按花色排序，则分成4堆，每堆再按A-K的顺序排序，使得整副扑克牌最终有序。

次位优先（LSD)

核心思想是：建桶。先排次重要的，重要的最后排。
比如对10000万位学生成绩排序，（假设0-99分），事位的权重比个位大，所以先排个位（次位）然后再排十位。

举个例子：

在这里插入图片描述

主位优先（MSD）

排序算法性能比较

主要标准是算法的时间复杂度和空间复杂度。常用的排序算法可用谐音的方式来记忆“冒择路兮快归堆”，“冒冒失失的选择道路的话，你就快到坟堆里了”。指的是冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、堆排序。

各种排序算法的时间复杂度和空间复杂度的性能评价如下：

在这里插入图片描述

快速排序代码：

#include<stdio.h>
#define CUTOFF 100
int T[100000];
void swap(int *a,int *b)
{
    int temp;
    temp=*a;
    *a=*b;
    *b=temp;
}
 
int median3(int a[],int left,int right)
{
//  printf("median3 got %d as left,%d as right\n",left,right);
    int middle=(left+right)/2;
    if(a[left]>a[right])
        swap(&a[left],&a[right]);
    if(a[left]>a[middle])
        swap(&a[left],&a[middle]);
    if(a[middle]>a[right])
        swap(&a[middle],&a[right]);
 
    swap(&a[middle],&a[right-1]);
//  printf("median3 got %d as a pivot,middle=%d\n",a[right-1],middle);
    return a[right-1];
}
 
void InsertionSort(int a[],int left ,int right)
{
    int i,j,temp;
    for(i=left;i<right;i++)
    {
        temp=a[i+1];
        for(j=i+1;j>left;j--)
        {
            if(temp<a[j-1])
                a[j]=a[j-1];
            else break;
        }
        a[j]=temp;
    }
}
void quicksort(int a[],int left,int right)
{
    int low,high,pivot;
    low=left;
    high=right-1;
    if(right-left<=CUTOFF)
    {
        InsertionSort(a,left,right);
        return;
    }
     
    pivot=median3(a,left,right);
    while(1)
    {
        while(a[++low]<pivot);
        while(a[--high]>pivot);
        if(low<high)
            swap(&a[low],&a[high]);
        else break;
    }
    swap(&a[low],&a[right-1]);
    quicksort(a,left,low-1);
    quicksort(a,low+1,right);
}
 
int main()
{
    int i,N;
    scanf("%d",&N);
    for(i=0;i<N;i++)
    {
        scanf("%d",&T[i]);
    }
    quicksort(T,0,N-1);
 
    for(i=0;i<N;i++)
    {
        printf("%d",T[i]);
        if(i!=N-1)
        printf(" ");
    }
}

#include<iostream>
using namespace std;
#define  ElementType long int

void Swap(ElementType &a,ElementType&b){
	//a^=b;b^=a;a^=b;
	ElementType t;
	t=a;
	a=b;
	b=t;
}


ElementType Median3(ElementType A[],int Left,int Right){
	int Center=(Left+Right)/2;
	if(A[Left]>A[Center]) Swap(A[Left],A[Center]);
	if(A[Left]>A[Right])  Swap(A[Left],A[Right]);
	if(A[Center]>A[Right])Swap(A[Center],A[Right]);
	Swap(A[Center],A[Right-1]);
	return A[Right-1];

	
}

void InsertionSort(ElementType a[],int Left ,int Right)
{
    int i,j,temp;
    for(i=Left;i<Right;i++)
    {
        temp=a[i+1];
        for(j=i+1;j>Left;j--)
        {
            if(temp<a[j-1])
                a[j]=a[j-1];
            else break;
        }
        a[j]=temp;
    }
}


void QuickSort(ElementType A[],int Left,int Right){
	int CutOff=1000;
	if(Right-Left<=CutOff) {
		InsertionSort(A,Left,Right);
		return;
	}
	int Privot=Median3(A,Left,Right);
	int Low=Left;
	int High=Right-1;
	//
	while(1){
		while(A[ ++Low  ] < Privot);
		while(A[ --High ] > Privot);
		if(Low < High ) Swap(A[Low],A[High]);
		else break;		
	}
	Swap(A[Low],A[Right-1]);
		//现在Low跑到了中间位置 
	QuickSort(A,Left,Low-1);
	QuickSort(A,Low+1,Right); 
	
	
}

void QSort(ElementType A[],int N){
	QuickSort(A,0,N-1);
}
int main(){
	int N,i;cin>>N;
	long int *A;
	A=new long int[N];
	for(int i=0;i<N;i++)cin>>A[i];
	QSort(A,N);
	for(i=0;i<N-1;i++)
		cout<<A[i]<<' ';
		cout<<A[i];
	delete[] A;
	return 0;	
}