排序总结(标题必须五个字)

O（N^2）

冒泡排序

void BubbleSort1(int array[], int n)
{
	for (int i = 0; i < n-1; i++)
	{
		for (int j = i + 1; j < n-1; j++)
		{
			if (array[i]>array[j])
                {
                    int t=array[i];
                    array[i]=array[j];
                    array[j]=t;
                }
		}
	}
}

插入排序

void Insertsort(int A[],int N)
{
    int t;
    for(int i=0;i<N;i++)
    {
        int j;
        t=A[i];
        for(j=i;j>0&&A[j-1]>t;j--)//先找到A[i]应该在的位置，再插入
        {
            A[j]=A[j-1];//逐一后移
        }
        A[j]=t;
    }
}

O（NlogN）

希尔排序

void Shellsort(int A[],int N)
{
    int i,j,Increment;
    int tmp;
    for(Increment=N/2;Increment>0;Increment/=2)//排序间隔
    {
        for(i=Increment;i<N;i++)
        {
            tmp=A[i];
            for(j=i;j>=Increment;j-=Increment)
            {
                if(tmp<A[j-Increment])
                {
                    A[j]=A[j-Increment];
                }
                else break;
            }
            A[j]=tmp;
        }
    }
}

基数排序

#include<string.h>//基数排序
#include<stdlib.h>
#include<stdio.h>
#define N 10	//数组长度
#define D 10	//最大位数

int GetDigit(int M, int i) //取整数M的第i位数
{
	while(i > 1)
	{
		M /= 10;
		i--;
	}
	return M % 10;
}

void RadixSort(int num[], int len)
{
	int i, j, k, l, digit;
	int allot[10][N];	//分配数组

	memset(allot, 0, sizeof(allot));//初始化《分配数组》

	for(i = 1; i <= D; i++)
	{
		int flag = 0;
		//分配相应位数的数据，并存入《分配数组》
		for(j = 0; j < len; j++)	
		{			
			digit = GetDigit(num[j], i);
			k = 0;
			while(allot[digit][k])
				k++;
			allot[digit][k] = num[j];
			if(digit) //判断是否达到了最高位数
				flag = 1;
		}
		if(!flag)	//如果数组每个数的第i位都为零
			break;	//即可直接退出循环

		//将《分配数组》的数据依次收集到原数组中
		l = 0; 
		for(j = 0; j < 10; j++)	
		{	
			k = 0;
			while(allot[j][k] > 0)
			{
				num[l++] = allot[j][k];
				k++;
			}
		}
		//每次分配，收集后初始化《分配数组》，用于下一位数的分配和收集
		memset(allot, 0, sizeof(allot));
	}
}

int main()
{
	int num[N] = {52, 20, 4, 10, 17, 39, 8, 300, 60, 81};

	RadixSort(num, N);

	for(int i = 0; i < N; i++)
		printf("%d ", num[i]);
	printf("\n");
    system("pause");
	return 0;
}

堆排序

#define LeftChild(i) ((2*i)+1)
void Perdown(int A[],int i,int N)//维护一个大根堆
{
    int child;
    int temp;
    for(temp=A[i];LeftChild(i)<N;i=child)//模拟二叉堆的构造操作
    {
        child=LeftChild(i);
        if(child!=N-1&&A[child+1]>A[child])
        child++;
        if(temp<A[child])
        A[i]=A[child];
        else break;
    }
    A[i]=temp;
}
void Heapsort(int A[],int N)
{
    int i;
    for(int i=N/2;i>=0;i--)//构造堆
    {
        Perdown(A,i,N);
    }
    for(int i=N-1;i>0;i--)
    {
        Swap(&A[0],&A[i]);//delete操作
        Perdown(A,0,i);//维持堆的有序性
    }
}

归并排序

int a[100];//需要排序的数组
int b[100];//辅助数组
void msort(int l,int r)//排序范围为[1,N](闭区间)
{
	if (l == r)return;
	int mid = (l + r) >> 1;
	msort(l, mid);
	msort(mid, r);
	int pos = l;
	int lpos = l;
	int rpos = mid + 1;
	while (lpos <= mid && rpos <= r)//分治思想，此时把数组分为两块，lpos为左边的指针，rpos为右边的指针，pos为合并指针
	{
		if (a[lpos] <= a[rpos])b[pos++] = a[lpos++];//把两个指针指向的数据较小的一个放到辅助数组中
		else b[pos++] = a[rpos++];
	}
	while (lpos <= mid)b[pos++] = a[lpos++];//右边指针指完了，左边剩下的拷贝进来
	while (rpos <= r)b[pos++] = a[rpos++];//同理
	for (int t = l; t <= r; t++)
	{
		a[t] = b[t];//拷贝到a数组
	}
}

快速排序

/*
快速排序
    找到一个枢纽元，用两个指针将数组分为大于枢纽元和小于枢纽元的两部分
    利用递归，再次寻找分成两个数组中的枢纽元，再次分开，直到数组有序
*/
void QuickSort(int A[],int N)
{
    Qsort(A,0,N-1);
}
int Median3(int 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]);
    //保证left<=center<=right
    swap(&A[center],&A[Right-1]);//枢纽元放在最后一个
    return A[Right-1];
}
void Qsort(int A[],int Left,int Right)
{
    int i,j,prvot;
    if(Left+3<=Right)//数组中有足够的值取枢纽元
    {
        prvot=Median3(A,Left,Right);
        i=Left;
        j=Right-1;
        for(;;)
        {
            while(A[++i]<prvot){};//左指针找比枢纽元大的值
            while(A[--j]>prvot){};//右指针找比枢纽元小的值
            if(i<j)//i在j的左边
            {
                swap(&A[i],&A[j]);//交换二者所指向的值，维护左数组比枢纽元小，右数组比枢纽元大的性质
            }
            else break;
        }
        swap(&A[i],&A[Right-1]);//结束之后交换枢纽元和i最后所指的位置，将枢纽元作为边界放在左右两个数组中间
        Qsort(A,Left,i-1);
        Qsort(A,i+1,Right);//递归
    }
    else
    {
        Insertsort(A+Left,Left+Right-1);//数据较少时插入排序比较简单
    }
}
void Insertsort(int A[],int N)
{
    int t;
    for(int i=0;i<N;i++)
    {
        int j;
        t=A[i];
        for(j=i;j>0&&A[j-1]>t;j--)//先找到A[i]应该在的位置，再插入
        {
            A[j]=A[j-1];//逐一后移
        }
        A[j]=t;
    }
}