【笔试面试必备】Java排序汇总

package com.sprying;

import java.util.Random;

public class SimpleSort {

	/**
	 * 随机创建一个10个数的数列，待排序
	 */
	public int[] createArray()
	{
		Random random=new Random();
		int[] array=new int[10];
		for(int i=0;i<10;i++)
		{
			array[i]=random.nextInt(100)-random.nextInt(100);
		}
		return array;
	}
	/**
	 * 打印数列
	 * @param array
	 */
	public void printArray(int[] array)
	{
		int len=array.length;
		for(int i=0;i<len;i++){
			System.out.print(array[i]+" ");
		}
		System.out.println();
	}
	/**
	 * 交换元素
	 * @param array
	 * @param a
	 * @param b
	 */
	public void swap(int []array,int a,int b)
	{
		int temp=array[a];
		array[a]=array[b];
		array[b]=temp;
	}
	/**
	 * 冒泡排序
	 * 方法：相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），下一次循环是将其他的数进行类似操作。
	 * 比较次数O(n^2),n^2/2；交换次数O(n^2),n^2/4,时间复杂度O(n^2)
	 * @param array
	 */
	public void bubbleSort(int[] array)
	{
		int i,j,mark;
		int len=array.length;
		for(i=0;i<len-1;i++)//比较的轮数
		{
			mark=0;
			for(j=len-1;j>i;j--) //将相邻两个数进行比较，较小的数往前冒泡
			{
				if(array[j]<array[j-1])
				{
					swap(array,j,j-1);
					mark=1;
				}
			}
			if(mark==0)
			{
				return;
			}
		}
	}
	/**
	 * 选择排序
	 * 方法：每一趟从待排序的数据元素中选出最小（或最大）的一个元素， 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
	 * 比较次数O(n^2),n^2/2,交换次数O(n),n.,所以选择排序比冒泡排序快
	 * 时间复杂度为O(n^2)
	 * @param array
	 */
	public void selectSort(int[] array)
	{
		int i,j,mark;
		int len=array.length;
		for(i=0;i<len-1;i++)
		{
			mark=i;
			for(j=i+1;j<len;j++)
			{
				if(array[j]<array[mark])
				{
					mark=j;
				}
			}
			if(mark!=i){
				swap(array,i,mark);
			}
		}
	}
	/**
	 * 插入排序，时间复杂度O(n^2)
	 * 比较次数O(n^2),n^2/4
     * 复制次数O(n),n^2/4
     * 比较次数是前两者的一半，而复制所需的CPU时间较交换少，所以性能上比冒泡排序提高一倍多，而比选择排序也要快。
	 * @param array
	 */
	public void insertSort(int[] array)
	{
		int i,j,temp;
		int len=array.length;
		for(i=1;i<len;i++){
			if(array[i]<array[i-1]){
				temp=array[i];
				array[i]=array[i-1];
				for(j=i-1;j>=0&&(array[i]<array[j]);j--)
				{
					array[j]=array[j-1];
				}
				array[j]=temp;
			}
		}
	}
	public int partition(int[] array,int low,int high)
	{
		int pivot=array[low];
		while(low<high){
			while(low<high&&array[high]>=pivot)
				high--;
			if(low<high){
				array[low]=array[high];
			}
			while(low<high&&array[low]<=pivot)
				low++;
			if(low<high){
				array[high]=array[low];
			}
		}
		array[low]=pivot;
		return low;
	}
	public void qSort(int[] array,int low,int high)
	{
		if(low<high){
			int pivotLoc=partition(array,low,high);
			qSort(array,low,pivotLoc-1);
			qSort(array,pivotLoc+1,high);
		}
	}
	/**
	 * 快速排序，时间复杂度O(n^2)
	 * @param array
	 */
	public void quickSort(int[] array)
	{
		qSort(array,0,array.length-1);
	}
	/**
	 * 折半查找
	 * @param a
	 * @param key
	 * @return
	 */
	public void quickSort_1(int[] array,int low,int high)
	{
		int pivot,i,j;
		if(low<high)
		{
			i=low;
			j=high;
			pivot=array[i];
			while(i<j)
			{
				while(i<j&&(pivot<=array[j]))
					j--;
				if(i<j){
					array[i]=array[j];
					i++;
				}
				while(i<j&&(pivot>=array[i]))
					i++;
				if(i<j){
					array[j]=array[i];
					j--;
				}
			}
			array[i]=pivot;
			quickSort_1(array,low,i-1);//注意i--不行
			quickSort_1(array,i+1,high);//注意i++不行
		}
	}
	public int search_Bin(int a[],int key)
	{
		int low=0,high=a.length-1,mid;
		while(low<=high)
		{
			mid=(low+high)/2;
			if(key==a[mid]){
				return mid;
			}else if(key<a[mid])
				high=mid-1;
			else
				low=mid+1;			
		}
		return -1;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		SimpleSort sort=new SimpleSort();
		int[] array;
		array=sort.createArray();
		System.out.println("before bubbleSort:");
		sort.printArray(array);
		sort.bubbleSort(array);
		System.out.println("after bubbleSort:");
		sort.printArray(array);
		
		array=sort.createArray();
		System.out.println("before selectSort:");
		sort.printArray(array);
		sort.selectSort(array);
		System.out.println("after selectSort:");
		sort.printArray(array);
		
		array=sort.createArray();
		System.out.println("before insertSort:");
		sort.printArray(array);
		sort.insertSort(array);
		System.out.println("after insertSort:");
		sort.printArray(array);
		
		array=sort.createArray();
		System.out.println("before quickSort:");
		sort.printArray(array);
		sort.quickSort(array);
		System.out.println("after quickSort:");
		sort.printArray(array);
		
		array=sort.createArray();
		System.out.println("before quickSort_1:");
		sort.printArray(array);
		sort.quickSort_1(array,0,array.length-1);
		System.out.println("after quickSort_1:");
		sort.printArray(array);
		System.out.println(array[6]+" is at the position of "+sort.search_Bin(array,array[6]));
	}

}

参考： http://blog.csdn.net/zuoluoboy/article/details/4123943