常用的排序算法实现

排序工具类:

package sort;

public class SortUtil { 
    
    public static void swap(int[] array, int i, int j) { 
        int temp; 
        temp = array[i]; 
        array[i] = array[j]; 
        array[j] = temp; 
    } 
  
    public static void printArray(int[] array) { 
        for (int i : array) { 
            System.out.print(i + " "); 
        } 
    } 
  
} 

一：冒泡排序

package sort.bubble;

import sort.SortUtil;
//冒泡排序 时间复杂度:n*n
public class BubbleSort{
	public static void bubbleSort(int[] array) {
		for(int i=0;i<array.length;i++){
			boolean flag = false; //哨兵，如果一次遍历过程中没有一次swap，则提前结束排序
			for(int j=0;j<array.length-i-1;j++){
				if(array[j]<array[j+1]){
					flag = true;
					SortUtil.swap(array,j,j+1);//小的往上冒，由大到小
				}
			}
			if(!flag)
				break;
		}
	}
	
	public static void main(String[] args){
		int[] array = new int[]{1,5,3,20,8};
		bubbleSort(array);
		SortUtil.printArray(array);
		bubbleSort(array);
	}
}

二：选择排序

package sort.select;

import sort.SortUtil;

/**
 * 选择排序：
 * 基本思想:取出数组中最小（或最大）的元素与数组的第一个元素互换，除去互换后的第一个元素后，剩下的数组中最小的与原数组的第二个置换，依此类推
 * 选择排序扫描一次数组只进行一次(或0次)swap
 * 算法复杂度: n * n
 * @author qianliangliang
 */
public class SelectSort {
	public static void selectSort(int[] array){
		for(int i=0;i<array.length;i++){
			int max_position = i;
			for(int j = i + 1;j < array.length;j++){
				if(array[max_position] < array[j])
					max_position = j;
			}
			if(i != max_position)
				SortUtil.swap(array,i,max_position);
		}
	}
	public static void main(String[] args){
		int[] array = new int[]{1,5,3,20,8};
		selectSort(array);
		SortUtil.printArray(array);
	}
}
	

三：插入排序

package sort.insert;

import sort.SortUtil;

/**
 * 插入排序：
 * 基本思想：依次对前N个元素进行排序（N=2，3，4），对第N个元素进行操作时，依次与之前的元素比较，找到可以插入的索引位置，之后的元素依次后移
 * 算法复杂度: n*n
 * @author qianliangliang
 */
public class InsertSort {
	public static void insertSort(int[] a){
		for(int i = 1; i < a.length; i++){
			int tmp = a[i];
			int j = i;
			
			for(; j > 0 && tmp > a[j - 1]; j--){
				a[j] = a[j - 1]; //将前面小的元素依次后移
			}
			
			a[j] = tmp;
		}
	}
	
	public static void main(String[] args){
		int[] array = new int[]{1,5,3,20,8};
		insertSort(array);
		SortUtil.printArray(array);
	}
}

四：快速排序

package sort.quick;

import sort.SortUtil;

/**
 * 快速排序:
 * 基本思想:取出数组中的任意一元素，将比此元素小的排在数组的前边，大的排在数组的后边，取出的元素存放在中间，下标称为基准线,然后再基准线左右两边的部分递归处理
 * 时间复杂度: n*logn
 * @author qianliangliang
 *
 */
public class QuickSort {
	public static void quickSort(int[] array){
		quickSort(array,0,array.length);
	}
	private static void quickSort(int[] array,int low,int high){
		if(low < high){
			int pivot = partition(array,low,high); //基准线
			quickSort(array,low,pivot-1);
			quickSort(array,pivot + 1,high);
		}
	}
	//快速排序，获取轴点（基准点）
	private static int partition(int[] array,int low, int high){
		int compare = array[high]; //取最后一元素作为基准元素
		int i = low - 1;
		for(int j = low; j < high; j++){
			if(array[j] > compare)
				SortUtil.swap(array, ++i, j);
		}
		SortUtil.swap(array, ++i, high);
		return i;
	}
}

参与资料:

1.http://blog.csdn.net/shanliangliuxing/article/details/7010607

2.http://www.cnblogs.com/oojdon/archive/2011/09/25/2190005.html

3.http://zh.wikipedia.org/wiki/%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95