java常用排序算法总结

1.  二分查找算法（默认数组从小到大排序）

package sort;
/**
 * 二分查找算法
 * @author zz
 * 递归算法
 */
public class BinarySearch {  
	   public static int binSearch(int[] a, int start,int end, int key) {
		   //每次都找到中间的那个索引
		   int mid=(end-start)/2+start;
		   //查询完毕
		   if(start>end){
			   return -1;
		   }
		   if(a[mid]==key){
			   return mid;
		   }
		   //要找的值大于中值得话，就从中值往后查找。
		  if(key>a[mid]){
			   return binSearch(a, mid+1, end, key);
		   }
		  //要找的值小于中值得话，就从中值往前查找。
		  if(key<a[mid]){
			  return binSearch(a, start, mid-1, key);
		  }
		  return -1;
		   

	    }  
       public static void main(String[] args) { 
           int srcArray[] = {1,3,5,7,9,11,13,15,17};   
           System.out.println(binSearch(srcArray, 0, srcArray.length - 1, 7));  
       } 
	}  

2.  冒泡排序算法

package sort;

import java.util.Arrays;

/**
 * 冒泡排序算法
 * @author zz
 * 将序列划分为无序和有序区，不断通过交换较大元素至无序区尾完成排序。
 */
public class BubbleSort {  
	   private static void bubbleSort(int[] a) {  
	        for (int i = 1; i <= a.length - 1;i++) {  
	           for (int j = 0; j <= a.length-1 - i; j++) {  
	       //每次循环比较前后两个值，如果大于后面就交换。
	       //第一次j循环是到0-a.length-1，之后是0-a.length-2，不停往前缩进，一直到0，所有序列排序完毕
	                if (a[j] > a[j + 1]) {  
	                    swap(a, j, j + 1);  
	                }  
	           }  
	       }  
	    }  
	   private static void swap(int[] a, int x, int y) {  
	       int tmp = a[x];  
	       a[x] = a[y];  
	       a[y] = tmp;  
	    }  
       public static void main(String[] args) { 
           int srcArray[] = {4,5,8,1,7,18,15,13,16,17};   
           bubbleSort(srcArray);
           System.out.println(Arrays.toString(srcArray));
       } 
	}  

3.  堆排序

package sort;

import java.util.Arrays;

/**
 * 堆排序
 * @author zz
 * 利用大根堆或小根堆思想，首先建立堆，然后将堆首与堆尾交换，堆尾之后为有序区。
 * (length/2,length)之后都是子节点，之前都是非子节点。
 * Parent(i)=(i-1)/2
 * Left(i)=2*i+1
 * Right(i)=2*i+2
 * 将父节点和子节点比较，如果小就交换
 */
public class HeapSort {  
	   private static void heapSort(int[] a) {  
	       // 先创建大堆，从第一个非叶子结点开始调整，然后依次调整
	       for (int i = a.length / 2-1; i >= 0 ; i--) {  
	       //三个参数，第一个：要排序的数组；第二个：要放入堆中的元素索引；第三个：需要维护的堆长度
	           Largeheap(a, i, a.length);  
	       }  
	       // 调整大堆，将最大的元素调整到未排好序的部分的末尾  
	       for (int i = a.length - 1; i >=0 ; i--) {  
	           swap(a, 0, i);  
	           Largeheap(a, 0, i);  
	       }  
	    }  
	   private static void Largeheap(int[] a, int i, int n) {  
		   int temp;//记录节点值
		   int child;//记录子节点最大值
		   for(temp=a[i];i*2+1<n;i=child){
			   child=i*2+1;//左孩子
			   //先比较左右孩子，child找到最大的孩子
			   if(child!=n-1&&a[child+1]>a[child]){
				   child++;
			   }
			   if(temp<a[child]){
				   swap(a, i, child);
				   //交换完毕，子节点又变了，所以要再次循环排序
			   }else{
				   break;
			   }
		   }
	    }  
	   private static void swap(int[] a, int x, int y) {  
	       int tmp = a[x];  
	       a[x] = a[y];  
	       a[y] = tmp;  
	    }  
       public static void main(String[] args) { 
           int srcArray[] = {4,5,2,8,1,19,7,18,15,13,16,17};   
           heapSort(srcArray);
           System.out.println(Arrays.toString(srcArray));
       } 
	}  

4.  插入排序

package sort;

import java.util.Arrays;

/**
 * 插入排序
 * @author zz
 *
 */
public class InsertSort {  
	   private static void insertSort(int[] a) {  
		   int temp;
		   for(int i=1;i<a.length;i++){
			   //保留要比较的值
			   temp=a[i];
			   for(int j=i;j>0&&temp<a[j-1];j--){
			   //每次比较之后发现小了，就交换顺序
				   swap(a, j, j-1);
			   }
		   }
	    }  
	   private static void swap(int[] a, int x, int y) {  
	       int tmp = a[x];  
	       a[x] = a[y];  
	       a[y] = tmp;  
	    } 
       public static void main(String[] args) { 
           int srcArray[] = {4,5,2,8,1,19,7,18,15,13,16,17};   
           insertSort(srcArray);
           System.out.println(Arrays.toString(srcArray));
       } 
	}  

5.  归并排序

package sort;

import java.util.Arrays;
/**
 * 归并排序
 * @author zz
 * 先一分为2，分别排序完毕后再归并。
 * 用一个复制数组保存数组的顺序。
 */
public class MergeSort {

	public static void main(String[] args) {
        int srcArray[] = {4,5,8,1,7,18,15,13,16,17};   
        int array[]=new int[srcArray.length];
        mergeSort(srcArray,array,0,srcArray.length-1);
        System.out.println(Arrays.toString(srcArray));
	}
	  public static void mergeSort(int[] a,int[] b,int start,int end){
		if(start<end){
		int mid=(start+end)/2;
		//递归先排序左边
		mergeSort(a, b, start, mid);
		//递归排序右边
		mergeSort(a, b, mid+1, end);
		//递归整合排序好的左边和右边
		mergeAll(a,b,start,mid+1,end);
		}
	}
	  public static void mergeAll(int[] a,int[] b,int leftstart,int middle,int rightend){
		  int numbers=rightend-leftstart+1;
		  int leftend=middle-1;
		  int rightstart=middle;
		  //temp表示数组b的索引
		  int temp=leftstart;
		  while(leftstart<=leftend&&rightstart<=rightend){
			  if(a[leftstart]<=a[rightstart]){
				  b[temp]=a[leftstart];
				  temp++;
				  leftstart++;
			  }else{
				  b[temp]=a[rightstart];
				  temp++;
				  rightstart++;
			  }
		  }
		  //当左边未循环完，右边循环完时，剩下的左边都依次添加到b[]里，因为左边本身是排序好的
		  while (leftstart<=leftend) {
			  b[temp++]=a[leftstart++];
			
		  }
		  //当右边未循环完，左边循环完时，剩下的右边都依次添加到b[]里，因为右边本身也是排序好的
		  while (rightstart<=rightend) {
			  b[temp++]=a[rightstart++];
			
		  }
		  //将排序好的数组b依次赋值给a数组
		  for(int i=0;i<numbers;i++,rightend--){
			  a[rightend]=b[rightend];
		  }
	  }

}

6.  快速排序

package sort;

import java.util.Arrays;
/**
 * 快速排序
 * @author zz
 * 不断寻找一个序列的中点，然后对中点左右的序列递归的进行排序，直至全部序列排序完成，使用了分治的思想。
 */
public class QuickSort {

	public static void main(String[] args) {
		 int srcArray[] = {4,5,8,1,7,18,15,13,16,17};   
	     quickSort(srcArray,0,srcArray.length-1);
	     System.out.println(Arrays.toString(srcArray));
	}
	public static void quickSort(int[] a,int start,int end){
		//设置边界（递归算法必须要的）
		if(start<end){
		//设置一个标记值（很重要）
		int temp=a[start];
		int i=start;
		int j=end;
		while(i<j){
			//从右边开始往左边找，找第一个比标记值小的数，没找到，j标签继续往左
			while(i<j&&a[j]>=temp){
				j--;
			}
			//找到j的值，将它的值给i
			a[i]=a[j];
			//从左边开始往右边找，找第一个比标记值大的数，没找到，i标签继续往右
			while(i<j&&a[i]<=temp){
				i++;
			}
			//找到i的值，将它的值给j
			a[j]=a[i];
			
		}
		//当i=j时结束这一轮，将i此时的位置替换成标记值，开始快速排序左边和右边
		a[i]=temp;
		quickSort(a, start, i-1);
		quickSort(a, i+1, end);
		}
	}

}

7.  选择排序

package sort;

import java.util.Arrays;

/**
 * 选择排序
 * @author zz
 * 将序列划分为无序和有序区，寻找无序区中的最小值和无序区的首元素交换，有序区扩大一个，循环最终完成全部排序
 */
public class SelectSort {

	public static void main(String[] args) {
        int srcArray[] = {4,5,8,1,7,18,15,13,16,17};   
        selectSort(srcArray);
        System.out.println(Arrays.toString(srcArray));
	}
	private static void swap(int[] a, int x, int y) {  
	       int tmp = a[x];  
	       a[x] = a[y];  
	       a[y] = tmp;  
	    }  
	public static void selectSort(int []a){
		//设置最小值的索引
		int temp;
		for(int i=0;i<a.length;i++){
			temp=i;
			//从i往后找，如果找到小的，就赋值给temp
			for(int j=i+1;j<a.length;j++){
				if(a[j]<a[temp]){
					temp=j;
				}
			}
			swap(a, i, temp);
		}
	}

}

8.  希尔排序

package sort;

import java.util.Arrays;

/**
 * 希尔排序
 * @author zz
 *
 */
/*
 * 先将序列按增量划分为元素个数相同的若干组，使用直接插入排序法进行排序，然后不断缩小增量直至为1，最后使用直接插入排序完成排序。
 * 增量的选择以及排序最终以1为增量进行排序结束。
 */
public class ShellSort { 
    public static void main(String[] args) { 
        int srcArray[] = {4,5,8,1,7,18,15,13,16,17};   
        shellSort(srcArray);
        System.out.println(Arrays.toString(srcArray));
    } 
	private static void swap(int[] a, int x, int y) {  
	       int tmp = a[x];  
	       a[x] = a[y];  
	       a[y] = tmp;  
	    }  
    private static void shellSort(int[] a) {  
    	//gap每次分组的索引差值
    	int gap;
    	for(gap=a.length/2;gap>0;gap/=2){
    		//循环gap之后的值，如果发现比它对应的gap之前的值小的话，叫交换。
    		for(int i=gap;i<a.length;i++){
    			if(a[i]<a[i-gap]){
    				swap(a, i, i-gap);
    			}
    		}
    	}
    }  
}