数据结构——排序

排序的定义
  假设含有n个记录的序列为{r1,r2,r3,...,rn}
  其相应的关键字为{k1,k2,k3,...,kn}
  需确定一种排序列p1,p2,p3,...,pn
  使其相应的关键字满足kp1<kp2<kp3<...<kpn关系
  即使得序列成为一个按关键字有序的序列{rp1,rp2,rp3,...,rpn}

排序的稳定性
  假设ki=kj(1<=i<=n,1<=j<=n,i!=j)
  在排序前
    序列中ri领先于rj(i<j)
  如果
    ri仍领先于rj，则称所用的排序方法是稳定的
    rj领先ri，则称所用的排序方法是不稳定的

内排序
  在排序的整个过程中，待排序的所有记录全部被放置在内存中

  排序算法的性能受3方面的影响
    时间性能：时间开销是衡量排序算法好坏的标志
    辅助空间：算法执行时所需要的额外内存空间
    算法的复杂性：算法过于复杂会影响算法的效率

外排序
  在排序的整个过程中，需要在内外存之间多次交换排序的记录

 

1 最简单的冒泡排序

void bubbleSort(int a[],int len) //int a[]等效于int *a
{
  for(int i=0;i<=len-1;i++)
  {
    for(int j=i+1;j<len;j++)
    {
      if(a[i]>a[j])
      {
        int temp=a[i];
        a[i]=a[j];
        a[j]=temp;
      }
    }
  }
}

void main()
{
  int a[]={7,3,5,9,1,8,2,4,6,0};
  bubbleSort(a,10);
}

2 真正的冒泡排序

void bubbleSort(int a[],int len)
{
  for(int i=0;i<=len-1;i++)
  {
    for(int j=len-1;j>=1+i;j--)
    {
      if(a[j]<a[j-1])
      {
        int temp=a[j];
        a[j]=a[j-1];
        a[j-1]=temp;
      }
    }
  }
}

void main()
{
  int a[]={7,3,5,9,1};
  bubbleSort(a,5);
}

3 冒泡排序的优化

void bubbleSort(int a[],int len)
{
  for(int i=0;i<len;i++)
  {
    bool flag=false;
    for(int j=len-1;j>=i+1;j--)
    {
      if(a[j]<a[j-1])
      {
        int temp=a[j];
        a[j]=a[j-1];
        a[j-1]=temp;
        flag=true;
      }
    }
    if(flag==false)
      continue;
  }
}

void main()
{
  int a[]={7,3,5,9,1};
  bubbleSort(a,5);
}

4 简单选择排序

void selectSort(int a[],int len)
{
  for(int i=0;i<len-1;i++)
  {
    int min=i;
    for(int j=i+1;j<len;j++)
    {
      if(a[min]>a[j])
      {
        min=j;
      }
    }
    if(i!=min)
    {
      int temp=a[i];
      a[i]=a[min];
      a[min]=temp;
    }
  }
}

void main()
{
  int a[]={7,3,5,9,1};
  selectSort(a,5);
}

5 直接插入排序

void insert(int a[],int n)
{
  for(int i=1;i<n;i++)
  {
    //把选择的元素放在临时变量中
    int t=a[i];
    int j=0;
    for(j=i-1;j>=0 && a[j]>t;j--)
    {
      a[j+1]=a[j];
    }
    a[j+1]=t;
  }
}

void main()
{
  int a[]={7,3,5,2,8};
  insert(a,5);
}

6 希尔排序

void shellSort(int a[],int len)
{
  int increment=len;
  while(increment>1)
  {
    increment=increment/3+1;
    for(int i=increment;i<len;i++)
    {
      int key=a[i];
      int j=i-increment;
      while(j>=0)
      {
        if(key<a[j])
        {
          int temp=a[j];
          a[j]=key;
          a[j+increment]=temp;
        }
        j=j-increment;
      }
    }
  }
}

void main()
{
  int a[]={7,3,5,2,8};
  shellSort(a,5);
}

7 堆排序

void heapAdjust(int a[],int s,int m)
{
  int temp;
  int child;
  for(temp=a[s];2*s+1<m;s=child)
  {
    child=2*s+1;  //数组下标是从0开始，所以不是2*s
    if(child!=m-1 && a[child]<a[child+1])
    {
      ++child;  //找到最大的儿子结点
    }
    if(temp<a[child])
    {     
      a[s]=a[child];
    }
    else
      break;
  }
  a[s]=temp;
}

void heapSort(int a[],int len)
{
  for(int i=len/2;i>=0;i--)
  {
    heapAdjust(a,i,len);  //构造堆
  }
  for(int i=len-1;i>0;i--)
  {
    int temp=a[0];
    a[0]=a[i];
    a[i]=temp;
    heapAdjust(a,0,i);
  }
}

void main()
{
  int a[]={7,3,5,2,8};
  heapSort(a,5);
}

8 归并排序

void mergeSort(int a[],int len)
{
  merge(a,a,0,len-1);
}

void mSort(int sr[],int tr1[],int s,int t)
{
  if(s==t)
  {
    tr1[s]=sr[s];
  }
  else
  {
    int tr2[MAXSIZE+1];
    int m=(s+t)/2;
    mSort(sr,tr2,s,m);
    mSort(sr,tr2,m+1,t);
    merge(tr2,tr1,s,m,t);
  }
}

void merge(int sr[],int tr[],int i,int m,int n)
{
  int j,k,l;
  for(int j=m+1,k=i;i<=m && j<=n;k++)
  {
    tr[k]=sr[i]<sr[j]?sr[i++]:sr[j++]
  }
  if(i<=m)
  {
    for(l=0;l<=m-i;l++)
    {
      tr[k+l]=sr[i+1];
    }
  }
  if(j<=n)
  {
    for(l=0;l<=n-j;l++)
    {
      tr[k+l]=sr[j+1];
    }
  }
}

void main()
{
  int a[]={7,3,5,2,8};
  mergeSort(a,5);
}

9 快速排序

  原理：

  1.按从小到大排序

  2.定义一个key=a[0]为基准元素，low=0；high=n-1(n为数组元素个数)；
  3.首先key与a[high]比较.如果key<=a[high],high就减1(即high--),直到找到一个比key小的数据(key>a[high])；然后交换此时的两个数据，并将low加1(即low++)；
  4.比较此时key与a[low]的大小.如果key>=a[low],low就加1(即low++)，直到找到一个比key大的数据(即key<a[low]),然后交换此时的两个数据，并将high减1(即high--)；
  5.重复3、4步骤，直到low=high，此时的数据相当于分为两个数组:等于key左边的数据都小于key，等于key右边的数据都大于key

  6.继续排序key左右两边的数据，重复2、3、4步骤

#include <stdio.h>

int main()
{
    int i;
    int a[]={35,12,37,-58,54,76,22};
    quicksort(a,0,6);
    for(i=0;i<7;i++)
    {
        printf("%d\n",a[i]);
    }
}

void swap(int *p,int *q)
{
    int buf;
    buf=*p;
    *p=*q;
    *q=buf;
    return;
}

int quicksort(int *a,int low,int high)
{
    int i=low;
    int j=high;
    int key=a[low];
    if(low>=high)
    {
        return;
    }
    while(low<high)
    {
        while(low<high && key<=a[high])
        {
            high--;//please
        }
        if(key>a[high])
        {
            swap(&a[low],&a[high]);
            low++;
        }
        while(low<high && key>=a[low])
        {
            low++;
        }
        if(key<a[low])
        {
            swap(&a[low],&a[high]);
            high--;
        }    
    }
    quicksort(a,i,low-1);
    quicksort(a,low+1,j);
}