排序算法总结

1.选择排序

  由大到小排序
  每次选出最大的元素和 A[i] 交换

  void selectSort(int A[],int n)
{
    int i,j;
    for(i=0;i<n;i++)
    {
        int temp=i;
        for(j=i+1;j<n;j++)
        {
            if(A[j]>A[temp])
            {
                temp=j;
            }
        }
        int m=A[temp];
        A[temp]=A[i];
        A[i]=m;
    }
}

2.插入排序

从大到小排序
进行n-1次数，每次找到当前元素的应该插入位置，当前序列中 A[i-1] 之前的序列师有序的

void insertSort(int A[],int n)
{
    int i,j;
    for(i=1;i<n;i++)
    {
        int temp=A[i];
        j=i;
        while(j>0&&temp>A[j-1])
        {
            A[j]=A[j-1];
            j--;
        }
        A[j]=temp;
    }
}

3.冒泡排序

每次两两比较进行交换，将最小值，交换到 A[n-i]

void maopaoSort(int A[],int n)
{
    for(int i=0;i<n-1;i++)
    {
        for(int j=0;j<n-i-1;j++)
        {
            if(A[j]<A[j+1])
            {
                int temp=A[j];
                A[j]=A[j+1];
                A[j+1]=temp;
            }
        }
    }
}

4.快排

快排 复杂度O(N*log2N)  //分治的思想
void quickSort(int A[],int left,int right)
{
    if(right<=left)
        return;
    int base=A[left];
    int i=left,j=right;
    while(i!=j)
    {
        while(i<j&&A[j]>=base)
            j--;
   
        while(i<j&&A[i]<=base)
            i++;
        if(i<j)
        {
            swap(A[i],A[j]);
        }
    }
    A[left]=A[i];
    A[i]=base;
    quickSort(A,left,i-1);
    quickSort(A,i+1,right);
}

5.归并排序

//有序序列均从由大到小
//A[left]~A[mid]  A[mid+1]~A[right]
void Merge(int A[],int left,int mid,int right)
{
    int i=left,j=mid+1;
    int len=right-left+1;
    int B[len];
    int k=0;
    while(i<=mid,j<=right)
    {
        if(A[i]>A[j])
            B[k++]=A[i++];
        else
            B[k++]=A[j++];
    }
    while(i<=mid)
        B[k++]=A[i++];
    while(j<=right)
        B[k++]=A[j++];
    for(int i=0;i<len;i++)
    {
        A[left+i]=B[i];
    }
}

//i 表示每个有序序列的长度  ，n表示A中元素个数
void MergeSort(int A[],int n)
{
    int left,right,mid;

    for(int i=1;i*2<=n;i=i*2)
    {
        left=0;
        while(left+i<n)
        {
            mid=left+i-1;
            right=mid+1;
            if(right>=n)
                right=n-1;
            Merge(A,left,mid,right);
            left++;
        }
    }
}

6.堆排序

//Heap[1] ~Heap [n]  存储数据 
//Heap[0] 不使用，所以Heap[i] 的左子节点 为Heap[2*i]   右子节点为Heap[2*i+1]  
const int maxn=1000;
int Heap[maxn]={-1,9,3,6,5,4,3,2,1,0,1};
int n=10;
//使用数组存储二叉树，下标从1开始

//now为当前下标
void downAdjust1(int now,int last)
{
    int max1;
    int i; //左孩子节点
    while(now*2<=last)
    {
        max1=now;
        i=now*2;
        if(Heap[i]>Heap[now])
            max1=i;
        if(i+1<=last&&Heap[i+1]>Heap[max1])
            max1=i+1;

        if(max1==now)
            break;
        else
        {
            int temp=Heap[now];
            Heap[now]=Heap[max1];
            Heap[max1]=temp;
            now=max1;
        }
    }
}


void CreateHeap1()
{
    for(int i=n/2;i>=1;i--)
        downAdjust1(i,n);
}

void HeapSort1()
{
    CreateHeap1();
    for(int i=n;i>1;i--)
    {
        swap(Heap[i],Heap[1]);
        downAdjust1(1,i-1);
    }
    for(int i=1;i<=n;i++)
        printf("%d ",Heap[i]);
}