快速排序的三种实现

1、轴固定在左边的实现。

package com.student.common;

import java.sql.Timestamp;



public class QuickSort1 {
	
	
    public static void main(String[] args) {
	
    	int [] number = {41,24,76,11,45,64,21,69,19,36};  	
      
    	sort(number);
    		     
	}
	
	 public static void sort(int[] number) { 
		 sort(number, 0, number.length-1);    
	 }
    
	 private static void sort(int[] number, int left, int right) {  
		 
		 if(left < right) { 
			
		  int s = number[left]; 
		 
		  int i = left;      
		  int j = right + 1;
		  
		  while(true) {                 
			  
			  while(i + 1 < number.length && number[++i] < s) ;     // 向右找           
			  
			  while(j -1 > -1 && number[--j] > s) ;     // 向左找
			   if(i >= j)     break;
			   
			   swap(number, i, j);       
		 }
		  
		  number[left] = number[j];   
		  number[j] = s;      
		  sort(number, left, j-1);   // 对左边进行递回   
		  sort(number, j+1, right);  // 对右边进行递回
		  
		}
	 }
	 
	 private static void swap(int[] number, int i, int j) {   
		 int t;
		 t = number[i];   
		 number[i] = number[j];
		 number[j] = t;    
	}

}

 

2、轴也参与进来排序的实现。

package com.student.common;

import java.util.Date;



public class QuickSort2 {
	
	  public static void main(String[] args) {
			
	    	int [] number = {41,24,76,11,45,64,21,69,19,36};
	    	
	      　 sort(number); 
	  
	    	
	　}
		
		 public static void sort(int[] number) { 
			 sort(number, 0, number.length-1);    
		 }
	    
		 private static void sort(int[] number, int left, int right) {  
			 
			 if(left < right) { 
				
			  int s = number[(left+right)/2]; 
			 
			  int i = left-1;      
			  int j = right + 1;
			  
			  while(true) {                 
				  
				  while(i + 1 < number.length && number[++i] < s) ;     // 向右找           
				  
				  while(j -1 > -1 && number[--j] > s) ;     // 向左找
				   if(i >= j)     break;
				   
				   swap(number, i, j);       
			 }
			  
			  
			  sort(number, left, i-1);   // 对左边进行递回   
			  sort(number, j+1, right);  // 对右边进行递回
			  
			}
		 }
		 
		 private static void swap(int[] number, int i, int j) {   
			 int t;
			 t = number[i];   
			 number[i] = number[j];
			 number[j] = t;    
		}

}

 

3、轴的选择是快速排序法的效率关键之一，在这边的快速排序法的轴选择方式更加快了快速排序法的效率，它是来自演算法名书 Introduction to Algorithms 之中。

 

先说明这个快速排序法的概念，它以最右边的值s作比较的标准，将整个数列分为三个部份，一个是小于s的部份，一个是大于s的部份，一个是未处理的部份

package com.student.common;

public class QuickSort3 {
	
	
	 public static void main(String[] args) {
			
	    	int [] number = {41,24,76,11,45,64,21,69,19,36};
	    	
	    
	    	sort(number);
	     for(int j : number)
	     System.out.println(j);
	    	
	    	
	}
	
	 public static void sort(int[] number) { 
		 sort(number, 0, number.length-1);    
	 }
    
	 private static void sort(int[] number, int left, int right) {  
		 if(left < right) {   
			 int q = partition(number, left, right);       
			 sort(number, left, q-1);    
			 sort(number, q+1, right);  
		} 
	 }
	
	private static int partition(int number[], int left, int right) {    
		int s = number[right]; 
		int i = left - 1;       
		
		for(int j = left; j < right; j++) {       
			if(number[j] <= s) {       
				i++;         
				swap(number, i, j);     
			}         
		}     
		swap(number, i+1, right);  
		return i+1; 
	}
	
	 private static void swap(int[] number, int i, int j) {   
		 int t;
		 t = number[i];   
		 number[i] = number[j];
		 number[j] = t;    
	}

}