四種常用排序演算法

##注：從小到大排

##氣泡排序##
特點：效率低，實現簡單
思想：每一趟將待排序序列中最大元素移到最後，剩下的為新的待排序序列，重複上述步驟直到排完所有元素。這只是氣泡排序的一種，當然也可以從後往前排。

public void bubbleSort(int array[]) {
		int t = 0;
		for (int i = 0; i < array.length - 1; i++)
			for (int j = 0; j < array.length - 1 - i; j++)
				if (array[j] > array[j + 1]) {
					t =
 
 array[j];
					array[j] = array[j + 1];
					array[j + 1] = t;
				}
	}

##選擇排序##
特點：效率低，容易實現。
思想：每一趟從待排序序列選擇一個最小的元素放到已排好序序列的末尾，剩下的為待排序序列，重複上述步驟直到完成排序。

public void selectSort(int array[]) {
		int t = 0;
		for (int i = 0; i < array.length - 1; i++){
			int index=i;
			for (int j = i + 1; j < array.
 
length; j++)
				if (array[index] > array[j])
					index=j;
			if(index!=i){ //找到了比array[i]小的則與array[i]交換位置
				t = array[i];
				array[i] = array[index];
				array[index] = t;
			}
		}
	}

##插入排序##
特點：效率低，容易實現。
思想：將陣列分為兩部分，將後部分元素逐一與前部分元素比較，如果前部分元素比array[i]小，就將前部分元素往後移動。當沒有比array[i]小的元素，即是合理位置，在此位置插入array[i]

public void insertionSort(int array[]) {
		int i, j, t = 0;
		for (i = 1; i < array.length; i++) {
			if(a[i]<a[i-1]){
				t = array[i];
				for (j = i - 1; j >= 0 && t < array[j]; j--)
					array[j + 1] = array[j];
				//插入array[i]
				array[j + 1] = t;
			}
		}
}

快速排序

特點：高效，時間複雜度為nlogn。
採用分治法的思想：首先設定一個軸值pivot，然後以這個軸值為劃分基準將待排序序列分成比pivot大和比pivot小的兩部分，接下來對劃分完的子序列進行快排直到子序列為一個元素為止。

public void quickSort(int array[], int low, int high) {// 傳入low=0，high=array.length-1;
		int pivot, p_pos, i, t;// pivot->位索引;p_pos->軸值。
		if (low < high) {
			p_pos = low;
			pivot = array[p_pos];
			for (i = low + 1; i <= high; i++)
				if (array[i] > pivot) {
					p_pos++;
					t = array[p_pos];
					array[p_pos] = array[i];
					array[i] = t;
				}
			t = array[low];
			array[low] = array[p_pos];
			array[p_pos] = t;
			// 分而治之
			quickSort(array, low, p_pos - 1);// 排序左半部分
			quickSort(array, p_pos + 1, high);// 排序右半部分
		}

測試demo：

import java.util.Arrays;
public class sortTest {
	// 氣泡排序
	public void bubbleSort(int array[]) {
		int t = 0;
		for (int i = 0; i < array.length - 1; i++)
			for (int j = 0; j < array.length - 1 - i; j++)
				if (array[j] > array[j + 1]) {
					t = array[j];
					array[j] = array[j + 1];
					array[j + 1] = t;
				}
	}

	// 選擇排序
	public void selectSort(int array[]) {
		int t = 0;
		for (int i = 0; i < array.length - 1; i++){
			int index=i;
			for (int j = i + 1; j < array.length; j++)
				if (array[index] > array[j])
					index=j;
			if(index!=i){ //找到了比array[i]小的則與array[i]交換位置
				t = array[i];
				array[i] = array[index];
				array[index] = t;
			}
		}
	}

public void insertionSort(int array[]) {
		int i, j, t = 0;
		for (i = 1; i < array.length; i++) {
			if(a[i]<a[i-1]){
				t = array[i];
				for (j = i - 1; j >= 0 && t < array[j]; j--)
					array[j + 1] = array[j];
				//插入array[i]
				array[j + 1] = t;
			}
		}
}

	// 分治法快速排序
	public void quickSort(int array[], int low, int high) {// 傳入low=0，high=array.length-1;
		int pivot, p_pos, i, t;// pivot->位索引;p_pos->軸值。
		if (low < high) {
			p_pos = low;
			pivot = array[p_pos];
			for (i = low + 1; i <= high; i++)
				if (array[i] > pivot) {
					p_pos++;
					t = array[p_pos];
					array[p_pos] = array[i];
					array[i] = t;
				}
			t = array[low];
			array[low] = array[p_pos];
			array[p_pos] = t;
			// 分而治之
			quickSort(array, low, p_pos - 1);// 排序左半部分
			quickSort(array, p_pos + 1, high);// 排序右半部分
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] array = { 37, 47, 23, 100, 19, 56, 56, 99, 9 };
		sortTest st = new sortTest();
		// st.bubbleSort(array);
		// st.selectSort(array);
		// st.insertionSort(array);
		st.quickSort(array, 0, array.length - 1);
		System.out.println("排序後：" + Arrays.toString(array));
	}
}