氣泡排序

思路:就是每次將最大或最小的元素放到陣列的最後,so easy!時間複雜度為(O(n^2))
public class BubbleSort {
	public static void bubbleSort(int[] a) {
		for (int j = 1; j < a.length; j++) {
			for (int i = 0; i < a.length - j; i++) {
				if (a[i] > a[i + 1]) {
					int temp = a[i];
					a[i] = a[i + 1];
					a[i + 1] = temp;
				}
			}
		}
	}
	public static void main(String[] args) {
		int a[] = { 5, 2, 45, 7, 2, 4, 2, 45, 7, 2, 4, 2, 45, 7, 2, 4, 23, 7, 2, 3, 0, 43, 23, 12, 4, 1, 15, 7,
				3, 8, 31 };
		bubbleSort(a);
		for(int i = 0; i < a.length; i++){
			System.out.print(a[i]+" ");
		}
	}
}

選擇排序

思路:類似於冒泡,每次將後面最小的元素放在前面。時間複雜度為((O(n^2)))
public class SelectSort {
	public static void selectSort(int[] a) {
		int min;
		for (int i = 0; i < a.length - 1; i++) {
			min = i;
			for (int j = min + 1; j < a.length; j++) {
				if (a[min] > a[j]) {
					int temp = a[min];
					a[min] = a[j];
					a[j] = temp;
				}
			}
		}
	}

	public static void main(String[] args) {
		int a[] = { 5, 2, 45, 7, 2, 4, 2, 45, 7, 2, 4, 2, 45, 7, 2, 4, 23, 7,
				2, 3, 0, 43, 23, 12, 4, 1, 15, 7, 3, 8, 31 };
		selectSort(a);
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + " ");
		}
	}
}

插入排序

思路:從第二個元素開始,和之前的已排好序的字陣列的元素比較,找到合適的位置,然後後面的元素向後移動一位,再將該元素插入到前面合適的位置。時間複雜度為(O(n^2))
public class InsertSort {
	public static void insertSort(int[] a) {
		for (int i = 1; i < a.length; i++) {
			int key = a[i];
			int j = i - 1;
			while (j >= 0 && a[j] > key) {
				a[j+1] = a[j];
				j--;
			}
			a[j+1] = key;
		}
	}
	
	public static void main(String[] args) {
		int a[] = { 5, 2, 45, 7, 2, 4, 2, 45, 7, 2, 4, 2, 45, 7, 2, 4, 23, 7,
				2, 3, 0, 43, 23, 12, 4, 1, 15, 7, 3, 8, 31 };
		insertSort(a);
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + " ");
		}
	}
}

二分法排序

思路:插入排序的多此一舉,居然先用二分法查詢插入位置(多此一舉),然後再所有插入位置(二分法查出來的)後面的元素全部後移,太蛋疼了,插入法直接邊找邊後移多容易啊,這個事蛋疼的做法,下午想了一下做出來。(14、08、3)
package sort;

public class BinarySort {
	public static int binarySerch(int[] arr, int start, int end, int value) {
		int mid = -1;
		while (start <= end) {
			mid = (start + end) / 2;
			if (arr[mid] < value)
				start = mid + 1;
			else if (arr[mid] > value)
				end = mid - 1;
			else
				break;
		}
		if (arr[mid] < value)
			return mid + 1;
		else if (value < arr[mid])
			return mid;

		return mid + 1;

	}

	public static void binarySort(int[] arr, int start, int end) {
		for (int i = start + 1; i <= end; i++) {
			int value = arr[i];
			int insertLoc = binarySerch(arr, start, i - 1, value) ;
			for (int j = i; j > insertLoc; j--) {
				arr[j] = arr[j - 1];
			}
			arr[insertLoc] = value;
		}
	}

	public static void main(String[] args) {
		int[] arr = { 3, 5, 0, 8, 7, 9, 1, 2, 6, 4 };
		binarySort(arr, 0, arr.length - 1);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
	}
}


希爾排序

思路:類似於插入排序,只是每次所取的步長為(陣列的長度 /  2 / i)。時間複雜度為(n*log n)。
public class ShellSort {
	public static void shellSort(int[] a) {
		for (int gap = a.length / 2; gap > 0; gap /= 2)
			for (int i = gap; i < a.length; i++) {
				int key = a[i];
				int j = i - gap;
				while (j >= 0 && a[j] > key) {
					a[j + gap] = a[j];
					j -= gap;
				}
				a[j + gap] = key;
			}

	}

	public static void main(String[] args) {
		int a[] = { 5, 2, 45, 7, 2, 4, 2, 45, 7, 2, 4, 2, 45, 7, 2, 4, 23, 7,
				2, 3, 0, 43, 23, 12, 4, 1, 15, 7, 3, 8, 31 };
		shellSort(a);
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + " ");
		}
	}
}

快速排序

思路:關鍵在於求出partition()函式。我給出了兩種方法:1、從前到後。2、從前到中間,從後到中間。時間複雜度為(n * log n)最壞情況為
OK!show your my codes!
public class QuickSort {
	
	/*public static int partition(int[] a, int p, int r) {
		int x = a[r];
		int i = p - 1;
		for (int j = p; j < r; j++) {
			if (a[j] <= x) {//如果a[j]<x就將後面a[i]後面a[i+1](值大於x)與a[j](值<a[j])進行交換
				i++;
				
				int temp = a[i];
				a[i] = a[j];
				a[j] = temp;
				
			}
		}
		i++;
		int temp = a[i];
		a[i] = a[r];
		a[r] = temp;
		return i;
	}*/
	 
	public static int partition(int a[], int p, int r) {
		int x = a[p];
		int i = p;
		int j = r ;
		while (i < j) {
			while (a[j] >= x && i<j)
				j--;
			a[i] = a[j];//把小於X的那個數拿到前面的a【i】中
			while (a[i] <= x && i<j)
				i++;
			a[j] = a[i];//把大於X的那個數拿到後面的a【j】中
		}
		a[j] = x;//將X拿到分割處
		return j;
	}

	public static void quickSort(int[] a, int p, int r) {
		if (p < r) {
			int q = partition(a, p, r);
			quickSort(a, p, q-1);
			quickSort(a, q + 1, r);
		}
	}

	public static void main(String[] args) {
		int a[] = { 5, 2, 45, 7, 2, 4, 2, 45, 7, 2, 4, 2, 45, 7, 2, 4, 23, 7, 2, 3, 0, 43, 23, 12, 4, 1, 15, 7,
				3, 8, 31 };
		quickSort(a, 0, a.length-1);
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + " ");
		}

	}
}

合併排序

思路:用分治的思想,將陣列分至最小,再合併即可,不懂自己google吧!時間複雜度為(n * log n )是一個穩定的排序演算法。
public class MergeSort {
	public static void merge(int A[], int p, int q, int r) {
		int[] L = new int[q - p + 1];
		int[] R = new int[r - q];
		for (int i = p, j = 0; i <= q; i++, j++) {
			L[j] = A[i];
		}
		for (int i = q + 1, j = 0; i <= r; i++, j++) {
			R[j] = A[i];
		}
		int pos = p;
		int i = 0, j = 0;
		for (; i < L.length && j < R.length;) {
			if (L[i] <= R[j]) {
				A[pos++] = L[i++];
			} else {
				A[pos++] = R[j++];
			}
		}
		if (i < L.length) {
			for (; i < L.length;)
				A[pos++] = L[i++];
		} else if (j < R.length) {
			for (; j < R.length;)
				A[pos++] = R[j++];
		}
	}

	public static void mergeSort(int[] A, int p, int r) {
		if (p < r) {
			int q = (p + r) / 2;
			mergeSort(A, p, q);
			mergeSort(A, q + 1, r);
			merge(A, p, q, r);
		}
	}

	public static void main(String[] args) {
		int A[] = { 5, 2, 45, 7, 2, 4, 2, 45, 7, 2, 4, 2, 45, 7, 2, 4, 23, 7, 2, 3, 0, 43, 23, 12, 4, 1, 15, 7,
				3, 8, 31 };
		mergeSort(A, 0, A.length - 1);
		for (int i = 0; i < A.length; i++) {
			System.out.print(A[i] + " ");
		}
	}
}

堆排序

思路:建立一個堆,大頂堆或者小頂堆都可以。每次將堆頂元素放到陣列最後,然後堆的規模減小一個,再維持第一個元素的大頂堆性質。時間複雜度為(n * log n)。
public class HeapSort {
	//求雙親位置
	static int parent(int i) {
		return i / 2;
	}
	//求左孩子位置
	static int left(int i) {
		return 2 * i;
	}
	//求右孩子位置
	static int right(int i) {
		return 2 * i + 1;
	}
	//維持大頂堆的性質
	static void maxHelpify(int[] A, int i) {
		int l = left(i);
		int r = right(i);
		int largest = 0;
		if (l <= A[0] && A[l] > A[i])
			largest = l;
		else
			largest = i;
		if (r <= A[0] && A[r] > A[largest])
			largest = r;
		if (largest != i) {
			int temp = A[largest];
			A[largest] = A[i];
			A[i] = temp;
			maxHelpify(A, largest);
		}
	}
	//建立大頂堆
	static void buildMaxHeap(int[] A){
		for(int i=(A.length-1)/2; i>0; i--){
			maxHelpify(A, i);
		}
	}
	//堆排序
	public static void heapSort(int[] A){
		buildMaxHeap(A);//建立大頂堆
		//每次把堆頂的數放到陣列最後,然後把堆的大小減1,再次維持第一個數的大頂堆性質
		for(int i = A.length - 1; i>=2; i--){
			int temp = A[1];
			A[1] = A[i];
			A[i] = temp;
			A[0]--;
			maxHelpify(A, 1);
		}
	}
	public static void main(String[] args) {
		int A[] = new int[3];
		A[0] = A.length-1;//a[0]存放堆的大小
		for(int i = 1; i < A.length; i++){
			A[i] = (int) (Math.random()*10);
		}
		heapSort(A);
		for (int i = 1; i < A.length; i++) {
			System.out.print(A[i] + " ");
		}
	}
}

其他:還有一種計數排序。

比較簡單:就是將陣列下標作為元素的value,特殊情況下使用。如排序N個人的年齡就可以用計數排序。將年齡看作陣列的下標,定義一個大小為100的陣列,將年齡與之比較,如果年齡==下標就將,該下標的value+1.時間複雜度為(N)。