几种常用排序算法之二（归并排序、快速排序）

归并排序

用到分治策略,先把左边和右边排序，再合并左边和右边的元素。然后递归左右子数列。

class test
{
    static int[] cell=new int[14];
    
    public static void main(String[] args) 
    {
        int i;
        int[] arr={1,4,8,5,2,3,7,2,10,14,11,2,16,15};

        mergesort(arr,0,13);

        for(i=0;i<14;i++)
          System.out.printf("%3d",arr[i]);
        System.out.printf("
");
    }

    static void mergesort(int arr[],int left,int rigth)
    {
       int middle;

       if(left<rigth)
       {
          middle=(left+rigth)/2;
          mergesort(arr,left,middle);
          mergesort(arr,middle+1,rigth);
          merge(arr,left,middle,rigth);
       }
    }

    static void merge(int[] arr,int left,int middle,int rigth)
    {
       int li,ri;
       int h;

       li=left;    
       ri=middle+1;
       h=left;       

       while(li<=middle && ri<=rigth)  //两个数组都剩余元素，需要比较大小
       {
           if(arr[li]>arr[ri])
             cell[h++]=arr[ri++];
           else
             cell[h++]=arr[li++];
       }

       while(li<=middle)            //没有遍历完的数组，则直接拷贝剩下元素，因为两个数组都是有序的
           cell[h++]=arr[li++];
       while(ri<=rigth)
           cell[h++]=arr[ri++];

       for(h=left;h<=rigth;h++)//把合并好的元素拷贝回原来的数组
           arr[h]=cell[h];       
    }
}

快速排序

确定基准数，然后把小于基准数的放在左边，大于基准数的放在右边。递归直至完成。

class quick 
{
    static void swap(int arr[],int a,int b)
    {
       int cell;

       cell=arr[a];
       arr[a]=arr[b];
       arr[b]=cell;
    }
    
    static int median(int arr[],int left,int rigth)//先对左中右三个数进行排序
    {
       int middle;

       middle=(left+rigth)/2;
       if(arr[left]>arr[middle])
           swap(arr,left,middle);
       if(arr[left]>arr[rigth])
           swap(arr,left,rigth);
       if(arr[middle]>arr[rigth])
           swap(arr,middle,rigth);

       swap(arr,middle,rigth-1);  //隐藏基准数
       return arr[rigth-1];       //返回基准数
     }

    static void quicksort(int arr[],int left,int rigth)
    {
       int i,j;
       int pivot;

       if(left<rigth) 
       {  pivot=median(arr,left,rigth);    
          i=left;
          j=rigth-1;
          while(i<j)
          {               
             while(arr[++i]<pivot){}  //在左边找比基准数大的数
             while(arr[--j]>pivot){}  //在右边找比基准数大的数
             if(i<j)
               swap(arr,i,j);         //交换
             else
               break;
          }
          swap(arr,i,rigth-1);        //把基准数放回正确的位置，基准数位置确定下来了
          quicksort(arr,left,i-1);
          quicksort(arr,i+1,rigth);
       }
       else
          return;
    }

    public static void main(String[] args) 
    {
        int[] arr={1,2,1,5,4,7,8,3,6,5,7,-5};
        int i;
         
        quicksort(arr,0,11);
        for(i=0;i<12;i++)
          System.out.printf("%3d",arr[i]);
        System.out.printf("
");
    }
}