重温数据结构-排序算法

常见排序算法的对比：

排序算法	平均时间	最坏情况	辅助存储
简单排序	O(n*n)	O(n*n)	O(1)
希尔排序	O(n*logn)	O(n^s) 1<s<2	O(1)
快速排序	O(n*logn)	O(n*n)	O(1)
归并排序	O(n*logn)	O(n*logn)	O(n)
堆排序	O(n*logn)	O(n*logn)	O(1)

源代码[Java]

/*
 * $filename: SortAll.java,v $
 * $Date: 2014-3-9  $
 * Copyright (C) ZhengHaibo, Inc. All rights reserved.
 * This software is Made by Zhenghaibo.
 */
package edu.njupt.zhb;



/*
 *@author: ZhengHaibo  
 *web:     http://blog.csdn.net/nuptboyzhb
 *mail:    zhb931706659@126.com
 *2014-3-9  Nanjing,njupt,China
 */
public class SortAll {
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int []a = {12,5,6,98,45,2};
		//bubbleSort(a);
		//selectSort(a);
		//insertSort(a);
		//int []steps = {5,3,1};
		//shellSort(a,steps);
		//quickSort(a,0,a.length-1);
		
		int[] b = mergeSort(a);
		for(int e:b){
			System.out.println(e);
		}
		
	}
	/**
	 * 冒泡排序 从小到大
	 * 时间复杂度 O(n*n)
	 * @param data
	 */
	public static void bubbleSort(int []data){
		for(int i=0;i<data.length-1;i++){
			for(int j=i+1;j<data.length;j++){//将当前元素i后面的元素，依次与i进行对比
				if(data[j]<data[i]){
					int temp = data[j];
					data[j]=data[i];
					data[i]=temp;
				}
			}
		}
	}
	/**
	 * 简单选择排序 从小到大
	 * 时间复杂度 O(n*n) 与冒泡算法相比，减少了交换次数
	 * @param data
	 */
	public static void selectSort(int []data){
		for(int i=0;i<data.length-1;i++){
			int min = i;//初始化最小值
			for(int j=i+1;j<data.length;j++){//从剩余的data.length-i-1中找到最小的值
				if(data[j]<data[min]){
					min = j;
				}
			}
			if(min!=i){//不是初始值
				int temp = data[min];
				data[min]=data[i];
				data[i]=temp;
			}
		}
	}
	/**
	 * 插入排序 从小到大
	 * 时间复杂度O(n*n)
	 * @param data
	 */
	public static void insertSort(int []data){
		for(int i=1;i<data.length;i++){//可将data[0]自己看成有序的，然后逐步插入后面的数据
			int value = data[i];//取出待插入的值
			int j;
			for(j=i-1;j>=0&&value<data[j];j--){//从当前已经排序好的0~i进行扫描(从后面扫描),寻找待插入的位置
				data[j+1]=data[j];//从后面逐步移动
			}
			data[j+1]=value;//将待插入的值插入到j+1
		}
	}
	/**
	 * 希尔排序 从小到大
	 * 插入排序的改进
	 * @param data
	 */
	public static void shellSort(int []data,int []delta){
		for(int k=0;k<delta.length;k++){
			shellInsert(data, 0, data.length, delta[k]);
		}
	}
	/**
	 * 希尔插入
	 * @param data 待排序数组
	 * @param low  数组中的待排序区域
	 * @param high 
	 * @param deltaK 步长
	 */
	public static void shellInsert(int []data,int low,int high,int deltaK){
		for(int i=low+deltaK;i<high;i++){
			int value = data[i];
			int j;
			for(j=i-deltaK;j>=low&&value<data[j];j=j-deltaK){
				data[j+deltaK]=data[j];
			}
			data[j+deltaK] = value;
		}
	}
	/**
	 * 快速排序
	 * 平均时间复杂度O(n*logn)
	 * @param data 待排序数组
	 * @param low 数组的待排序区域
	 * @param high
	 */
	public static void quickSort(int []data,int low,int high){
		if(low<high){
			int partIndex = partition(data,low,high);
			quickSort(data, low, partIndex-1);
			quickSort(data, partIndex+1, high);
		}
	}
	/**
	 * 快速排序中 查找分割线枢纽part，使得右边的全部大于左边的
	 * @param data
	 * @param low
	 * @param high
	 * @return 返回枢纽的下标
	 */
	public static int partition(int []data,int low,int high){
		int value = data[low];//将最左端的值设置为枢纽值
		while(low<high){
			while(low<high&&data[high]>=value){//从右边向左边扫描，查找第一个小于枢纽值的下标
				high--;
			}
			data[low]=data[high];
			while(low<high&&data[low]<=value){//从左边向右边扫描，查找第一个大于枢纽值的下标
				low++;
			}
			data[high]=data[low];
		}
		data[low]=value;
		return low;
	}
	/**
	 * 归并排序
	 * 1.用递归的方式将数组分割成单个数据（单个数据可认为自己有序）
	 * 2.逐步合并已经有序的2个数组
	 * 平均时间复杂度O(n*logn) 最坏O(nlogn)
	 * @param data 待排序的数组
	 * @return
	 */
	public static int[] mergeSort(int []data){
		if(data.length<2){//递归：分割成了一个一个的数据
			return data;
		}
		int middle = data.length/2;
		int []leftData = new int [middle];
		int []rightData = new int[data.length-middle];
		System.arraycopy(data, 0, leftData, 0, middle);
		System.arraycopy(data, middle, rightData, 0, rightData.length);
		int []leftResult = mergeSort(leftData);
		int []rightResult = mergeSort(rightData);
		return merge(leftResult,rightResult);
	}
	/**
	 * 合并2个有序的数组
	 * @param leftResult 左边的有序数组
	 * @param rightResult 右边的有序数组
	 * @return
	 * result[i]=left (left<right)
	 * result[i]=right (left>=right)
	 */
	public static int [] merge(int []leftResult,int []rightResult){
		int []result = new int[leftResult.length+rightResult.length];//合并数组存放位置
		int leftIndex = 0;
		int rightIndex = 0;
		int resultIndex = 0;
		while(leftIndex<leftResult.length&&rightIndex<rightResult.length){
			if(leftResult[leftIndex]<rightResult[rightIndex]){
				result[resultIndex++]=leftResult[leftIndex++];
			}else {
				result[resultIndex++]=rightResult[rightIndex++];
			}
		}
		while(leftIndex<leftResult.length){
			result[resultIndex++]=leftResult[leftIndex++];
		}
		while(rightIndex<rightResult.length){
			result[resultIndex++]=rightResult[rightIndex++];
		}
		return result;
	}
	
	
}

归并排序的另外两种写法：

public static int[] mergeSort(int []data,int low,int high){
		if(low>=high){
			int []temp={data[low]};
			return temp;
		}
		int middle=(low+high)/2;
		int []left=mergeSort(data, low, middle);
		int []right=mergeSort(data, middle+1, high);
		return merge(left,right);
	}

	private static int[] merge(int[] left, int[] right) {
		// TODO Auto-generated method stub
		int []result=new int[left.length+right.length];
		int pa=0,pb=0,pc=0;
		while(pa<left.length&&pb<right.length){
			if(left[pa]<right[pb]){
				result[pc++]=left[pa++];
			}else {
				result[pc++]=right[pb++];
			}
		}
		while(pa<left.length){
			result[pc++]=left[pa++];
		}
		while(pb<right.length){
			result[pc++]=right[pb++];
		}
		return result;
	}

写法二：

public static void mergeSort(int []data,int low,int high){
		if(low<high){
			int middle=(low+high)/2;
			mergeSort(data, low, middle);
			mergeSort(data, middle+1, high);
			merge(data,low,middle,high);
		}
	}
	/**
	 * 将data数组中的low~middle和middle+1~high
	 * 两段数据合并
	 * @param data 数据
	 * @param low 起始位置
	 * @param middle 第一段的结束位置
	 * @param high 第二段的结束位置
	 * @return
	 */
	private static void merge(int[] data,int low,int middle,int high) {
		// TODO Auto-generated method stub
		int [] result=new int[high-low+1];
		int pa=low;
		int pb=middle+1;
		int pc=0;
		while(pa<=middle&&pb<=high){
			if(data[pa]<data[pb]){
				result[pc++]=data[pa++];
			}else {
				result[pc++]=data[pb++];
			}
		}
		while(pa<=middle){
			result[pc++]=data[pa++];
		}
		while(pb<=high){
			result[pc++]=data[pb++];
		}
		for(int i=0;i<result.length;i++){
			data[low+i]=result[i];
		}
	}

理解了算法的核心思想后，想怎么写都很容易

快速排序的另一种实现，java版本，比较好理解：

public class QuickSort {

    public static void main(String[] args) {

        List<Integer> arr = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            int a = new Random().nextInt(100);
            arr.add(a);
        }
        System.out.println("排序前：");
        System.out.println(arr);
        List<Integer> result = new QuickSort().quickSort(arr);
        System.out.println("排序后：");
        System.out.println(result);

    }

    public List<Integer> quickSort(List<Integer> arr) {
        if (arr == null || arr.size() <= 1) {
            return arr;
        }
        int p = arr.get(0);//取第一个作为基准值
        List<Integer> less = new ArrayList<>();//保存小于基准值的数组
        List<Integer> more = new ArrayList<>();//保存大于等于基准值的数据
        for (int i = 1; i < arr.size(); i++) {
            int item = arr.get(i);
            if (item < p) {
                less.add(item);
            } else {
                more.add(item);
            }
        }
        //对左边的进行排序
        List<Integer> left = quickSort(less);
        //对右面的进行排序
        List<Integer> right = quickSort(more);
        //以left数组来保存结果，将基准值和右边的加入到数组中
        left.add(p);
        left.addAll(right);
        return left;
    }
}