用java語言實現七大排序算法

自定義Sort接口

• Sort接口爲如下排序算法提供比較大小和元素的位置交換。

public abstract class Sort<T extends Comparable<T>> {

    public abstract void sort(T[] nums);

    protected boolean less(T v, T w) {
        return v.compareTo(w) < 0;
    }

    protected void swap(T[] a, int i, int j) {
        T t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

1.選擇排序

• 找出數組最小的元素放在第一個位置。接着，找出數組中剩餘的元素中最小的元素放在第二個位置，直到遍歷完這個數組。

public class Selection<T extends Comparable<T>> extends Sort<T> {

    @Override
    public void sort(T[] nums) {
        int N = nums.length;
        for (int i = 0; i < N - 1; i++) {
            int min = i;
            for (int j = i + 1; j < N; j++) {
                if (less(nums[j], nums[min])) {
                    min = j;
                }
            }
            swap(nums, i, min);
        }
    }
}

2.冒泡排序

• 從左往右不斷交換逆序的元素，通過一輪循環，最大的元素浮到最後側，在過程當中至少有一個元素的最終位置已經肯定好。

public class Bubble<T extends Comparable<T>> extends Sort<T> {

	@Override
	public void sort(T[] nums) {
	
		int N = nums.length;
		for (int i = 1; i < N; i++) {
			for (int j = 0; j < nums.length - i; j++) {
				if(less(nums[j+1], nums[j]))
					swap(nums, j+1, j);
			}
		}
	}
}

3.插入排序

每次都把當前元素插入左側已經排好序的數據，直到全部的元素都插入左側，就完成了對該數組的排序。

public class Insertion<T extends Comparable<T>> extends Sort<T> {
	@Override
	public void sort(T[] nums) {
		// TODO Auto-generated method stub
		int n = nums.length;
		for (int i = 1; i < nums.length; i++) {
			T val = nums[i];
			int j = 0;
			for (j = i - 1; j >= 0; j--) {
				if (less(val, nums[j]))
					nums[j + 1] = nums[j];
				else
					break;
			}
			nums[j + 1] = val;
		}
	}
}

4.希爾排序

• 希爾排序使用插入排序對間隔 h 的序列進行排序。經過不斷減少 h，最後令 h=1，就能夠使得整個數組是有序的

public class Shell <T extends Comparable<T>> extends Sort<T> {

	@Override
	public void sort(T[] nums) {
		int N = nums.length;
		int h = 1;

		while (h < N / 3) {
			h = 3 * h + 1; // 1, 4, 13, 40, ...
		}
		while (h >= 1) {
			for (int i = h; i < N; i++) {
				for (int j = i; j >= h && less(nums[j], nums[j - h]); j = j - h) {
					swap(nums, j, j - h);
				}
			}
			h = h / 3;
		}
	}
}

5.歸併排序

• 如下代碼使用自頂向下歸併排序，使用分治算法實現，把大問題分對半分紅兩個小問題，時間複雜度通常爲O(nlogn)
• merge方法對兩個子數組進行歸併，經過把原有的數據複製到輔助數據中，對比輔助中的兩個子數組依次按順序排入原有數組。

public class MergeSort<T extends Comparable<T>> extends Sort<T> {
	
	protected T[] aux;
	
	public void merge(T[] nums, int l, int m, int h) {
		int i = l, j = m + 1;

		for (int k = l; k <= h; k++) {
			aux[k] = nums[k];
		}

		for (int k = l; k <= h; k++) {
			if (j > h)
				nums[k] = aux[i++];
			else if (i > m)
				nums[k] = aux[j++];
			else if (aux[i].compareTo(aux[j]) <= 0)
				nums[k] = aux[i++];
			else
				nums[k] = aux[j++];
		}
	}
	@Override
	public void sort(T[] nums) {
	
		aux = (T[]) new Comparable[nums.length];
		sort(nums, 0, nums.length - 1);
	}
	public void sort(T[] nums, int l, int h) {
		if (h <= l)
			return;
		int m = l + (h - l) / 2;
		sort(nums, l, m);
		sort(nums, m + 1, h);
		merge(nums, l, m, h);
	}
}

6.快速排序

• 以切分爲基準分紅兩個子數組，左子數組小於切分元素，右子數組大於切分元素。當兩個子數組排好序時整個數組就排好序了。
• partition方法：
  • 取nums[l]爲切分元素，從左往右掃描直到找到一個大於它的元素，再從右往左掃描找到一個小於它的元素，交換這兩個元素的位置。
  • 不斷進行這個過程，直到指針i左側元素<切分元素，指針j右側元素大於切分元素。當兩個指針相遇時，交換指針i和指針j的位置。

public class QuickSort<T extends Comparable<T>> extends Sort<T> {
	private int partition(T[] nums, int l, int h) {
		int i = l, j = h + 1;
		T v = nums[l];
		while (true) {
			while (less(nums[++i], v) && i != h);
			while (less(v, nums[--j]) && j != l);
			if (i >= j)
				break;
			swap(nums, i, j);
		}
		swap(nums, l, j);
		return j;
	}

	@Override
	public void sort(T[] nums) {
		// TODO Auto-generated method stub
		shuffle(nums);
		sort(nums, 0, nums.length - 1);
	}

	public void sort(T[] nums, int l, int h) {
		if (h <= l)
			return;
		int j = partition(nums, l, h);
		sort(nums, l, j - 1);
		sort(nums, j + 1, h);
	}

	private void shuffle(T[] nums) {
		List<Comparable> list = Arrays.asList(nums);
		Collections.shuffle(list);
		list.toArray(nums);
	}
}

7.堆排序

• sort()：堆的構建，從右往左進行下沉操做。不斷用堆頂的元素與數組的最後一個元素交換，同時堆的大小不斷減一，直到堆的大小爲1，數組就排好序了。

public class HeapSort <T extends Comparable<T>> extends Sort<T> {
	@Override
	public void sort(T[] nums) {
		int N = nums.length - 1;
		for (int k = N / 2; k >= 1; k--) {
			sink(nums,k,N);
		}
	   
		while(N > 1) {
			swap(nums, 1, N--);
			sink(nums,1,N);
		}
	}
	private void sink(T[] nums, int k, int N) {
		while(2 * k  <=  N){
			int j = 2 * k;
			if(j < N && less(nums,j,j+1))
				j++;
			if(!less(nums,k,j))
				break;
			swap(nums, k, j);
			k = j;
		}
	}
	 
	private boolean less(T[] nums, int i, int j) {
        return nums[i].compareTo(nums[j]) < 0;
    }
}