四种经典排序算法解析-优快云博客

1.快排

(1)以一个枢轴为界分两组，小于基准值在左一组，大于基准值在右一组。

(2) 再把左一组和右一组也按照(1)中的那样找枢轴递归排序，一遍遍递归，直到从小到大的顺序完全出来为止。

public class TestSort{
  
    public static void main(String args[]){
       int a[]={5,4,9,8,7,6,0,1,3,2};
       quickSort(a);	 
       for(int i=0;i<a.length;i++){
   	   System.out.print(a[i]+" ");	
       }
    }	
	
    public static void quickSort(int array[]){
	sort(array,0,array.length-1);
    }
	
    public static void sort(int array[],int low,int high){
     	int i,j;
     	int index;
     	if(low>=high) return;
     	i=low;
     	j=high;
     	index=array[i];    //这个即为枢轴
	while(i<j){
	   while(i<j&&array[j]>=index) 
	      j--;
	      if(i<j)
	       	array[i++]=array[j];
	      while(i<j&&array[i]<index){
	        i++;	
	      }	   
	      if(i<j)
	        array[j--] = array[i];
	}
	array[i]=index;
	sort(array,low,i-1);
	sort(array,i+1,high);
	}
}

2.归并排序. [5,4,9,8,7,6,0,1,3,2]

(1)将数组分成两组，第一组是原来的数组的前一半，第二组是数组的另一半。[5，4，9，8，7] [6，0，1，3，2]

(2)两组内都按照从大到小的顺序排好了。[9，8，7，5，4] [6，3，2，1，0]

(3)两组合并，比较整合，得到最终的从大到小的数组的排序。[9，8，7，6，5，4，3，2，1，0]

<pre name="code" class="java">public class TestSort{    
      
    public static void main(String args[]){    
       int a[]={5,4,9,8,7,6,0,1,3,2};    
       MergeSort(a,0,a.length-1);        
       for(int i=0;i<a.length;i++){    
           System.out.print(a[i]+" ");      
       }    
    }       
        
    public static void MergeSort(int array[],int p,int r){    
       if(p<r){  
           int q = (p+r)/2;  
           MergeSort(array,p,q);  
           MergeSort(array,q+1,r);//这两行将数组分成两部分，不断的递归  
           Merge(array,p,q,r);  
       }    
    }    
        
    public static void Merge(int array[],int p,int q,int r){    
        int i,j,k,n1,n2;  
        n1=q-p+1;  
        n2=r-q;  
        int L[]=new int[n1];  
        int R[]=new int[n2];  
        for(i=0,k=p;i<n1;i++,k++){   //把数组的前5个元素放在L[]数组里  
            L[i]=array[k];  
        }  
        for(i=0,k=q+1;i<n2;i++,k++){  //把数组的后5个元素放在R[]数组里  
            R[i]=array[k];  
        }  
        for(k=p,i=0,j=0;i<n1&&j<n2;k++){ //再把数组L[]和R[]里面的值按照从小到大放到数组array[]中来，注意i，j的范围  
           if(L[i]<R[j]){  
            array[k]=L[i];  
            i++;  
           }  
           else{  
               array[k]=R[j];  
               j++;  
           }  
        }  
        if(i<n1){      //这两个if语句表示i<n1&&j<n2中有一个已经到最大值，不满足条件，另一个有剩余，把剩余的拿出来
            for(j=i;j<n1;j++,k++)  
            array[k]=L[j];  
        }  
        if(j<n2){  
           for(i=j;i<n2;i++,k++)  
           array[k]=R[i];  
        }  
          
    }    
}

3.堆排序(由于这里用了小顶堆，因此输出的是从大到小的，要用大顶堆输出的就是从小到大的了)

(1)先把数组层序遍历成一棵完全二叉树。

(2)将该二叉树调整为一个小顶堆。

(3)将堆的根节点的元素与最后一个节点的元素交换，最后一个节点的元素就变成了最小值，即a[n-1]就等于这个最小值。依次递归，知道一个个方法最后。

(4)将除了最后一个元素的剩下的元素再次调整为一个小顶堆。

public class TestSort{  
    
    public static void main(String args[]){  
       int a[]={5,4,9,8,7,6,0,1,3,2};  
       minHeapSort(a);         //最小堆的排序算法
       for(int i=0;i<a.length;i++){  
           System.out.print(a[i]+" ");    
       }  
    }     
      
    public static void minHeapSort(int array[]){  
      int i;
      int len=array.length;
      for(i=len/2-1;i>=0;i--){ //这个for循环用于把原来的数组第一次生成一个最小堆，注意第一个元素从a[len/2-1]开始，因为这才开始有孩子节点
    	  adjustMakeMinHeap(array,i,len-1);
      }
      for(i=len-1;i>=0;i--){  //这个for循环用于把最小堆的树根节点跟最后一个节点交换，并把剩下的len-1个节点重新生成最小堆，直到结束
    	  int temp=array[0];
    	  array[0]=array[i];
    	  array[i]=temp;
    	  adjustMakeMinHeap(array,0,i-1);
      }
      
    }  
      
    public static void adjustMakeMinHeap(int a[],int pos,int len){  //这个方法用于把原来的数组第一次生成一个最小堆
        int temp,child;
        for(temp=a[pos];2*pos+1<=len;pos=child){
        	child=2*pos+1;
        	if(child<len&&a[child]>a[child+1])  //这里child取两个孩子节点中元素最小的下标
        	  child++;
        	if(a[child]<temp)  //两个孩子节点的元素比最小的还小，让孩子节点替代父母节点
        	   a[pos]=a[child];
        	else
        	   break;
        }
        a[pos]=temp;  //这里表示的是上面的child=2*pos+1或者基础上child++;  pos=child，给小儿子节点赋值
    }  
}

4.希尔排序 [5,4,9,8,7,6,0,1,3,2]

(1)h=5时，i从a[5]开始，让a[5]与a[0]比，小了就交换，往前移动，同理a[6]与a[1]，a[7]与a[2]，a[8]与a[3]，a[9]与a[4]比较，都是小了就交换。

[5，0，1，3，2，6，4，9，8，7]

(2)h=2时，i从a[2]开始，让a[2]与a[0]比，小了就交换往前移动，同理a[3]与a[1]，a[4]与a[2]、a[0]，a[5]与a[3]、a[1]，a[6]与a[4]、a[2]、a[0]比，a[7]与a[5]，a[3]，a[1]比，a[8]与a[6]、a[4]、a[2]、a[0]比a[9]与a[7]a[5]、a[3]、a[1]比，都是小了就往前换。[1，0，2，3，4，6，5，7，8，9]

(3)h=1时，i从a[1]开始，让a[1]与a[0]比，小了就交换，a[2]与a[1]，a[0]比，a[3]与a[2]、a[1]、a[0]比......a[9]与a[8]、a[7]......a[1]、a[0]比，都是小了就交换。

[0，1，2，3，4，5，6，7，8，9]

public class TestSort{  
    public static void main(String args[]){  
       int a[]={5,4,9,8,7,6,0,1,3,2};  
       shellSort(a);         //最小堆的排序算法
       for(int i=0;i<a.length;i++){  
           System.out.print(a[i]+" ");    
       }  
    }     
      
    public static void shellSort(int array[]){  
      int i,j,h,temp;
      int len=array.length;
      for(h=len/2;h>0;h=h/2){
    	  for(i=h;i<len;i++){
    		  temp=array[i];
    		  for(j=i-h;j>=0;j-=h){
    			  if(temp<array[j]){
    				  array[j+h]=array[j];  //注意
    			  }
    			  else
    				  break;
    		  }
    		  array[j+h]=temp;  //这一行也得有啊
    	  }
      }
    }  
}