?

?1、冒泡排序 Bubble Sort

?

? ? ? ? 最簡單的排序方法是冒泡排序方法。這種方法的基本思想是，將待排序的元素看作是豎著排列的“氣泡”，較小的元素比較輕，從而要往上浮。在冒泡排序算法中我們要對這個“氣泡”序列處理若干遍。所謂一遍處理，就是自底向上檢查一遍這個序列，并時刻注意兩個相鄰的元素的順序是否正確。 如果發(fā)現(xiàn)兩個相鄰元素的順序不對，即“輕”的元素在下面，就交換它們的位置 。顯然，處理一遍之后，“最輕”的元素就浮到了最高位置；處理二遍之后，“次輕”的元素就浮到了次高位置。在作第二遍處理時，由于最高位置上的元素已是“最輕”元素，所以不必檢查。一般地，第i遍處理時，不必檢查第i高位置以上的元素，因為經(jīng)過前面i-1遍的處理，它們已正確地排好序。這個算法可實現(xiàn)如下。

?

?

2、選擇排序 Selection Sort

?

? ? ? ? 選擇排序的基本思想是：對待排序的記錄序列進行n-1遍的處理，第1遍處理是將L[1..n]中最小者與L[1]交換位置，第2遍處理是將L[2..n]中最小者與L[2]交換位置，......，第i遍處理是將L[i..n]中最小者與L[i]交換位置。這樣，經(jīng)過i遍處理之后，前i個記錄的位置就已經(jīng)按從小到大的順序排列好了。

　　當然，實際操作時，也可以根據(jù)需要，通過從待排序的記錄中選擇最大者與其首記錄交換位置，按從大到小的順序進行排序處理。

?

備注：個人理解冒泡排序是每次和相鄰的數(shù)據(jù)比較之后（如果符合條件）就進行交換；

而選擇排序是每次選擇最小的，確定之后再做交換，然后依次放在數(shù)組的最前或者最后面

?

?

?

?

?

?

      package hb.mm;

import java.util.LinkedList;

public class SortDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] arr = { 5, 6, 2, 7, 1, 3, 53, 8 };

		// int[] result = doBubbleSort(arr);
		// int[] result = doChooseSort(arr);
		//int[] result = doInsertSort_for(arr);
		int[] result = doInsertSort_while(arr);
		
		new LinkedList();

		printArr(result);
	}

	/**
	 * 循環(huán)數(shù)組
	 * @param arr 需要便利的數(shù)組
	 */
	public static void printArr(int[] arr) {
		for (int a : arr) {
			System.out.println(a);
		}
	}

	/**
	 * 插入排序 使用while循環(huán)  
	 * @param arr
	 * @return
	 */
	public static int[] doInsertSort_while(int[] arr){
		int length = arr.length;
		//從第一個數(shù)組開始，與第零個比較
		for(int i=1;i<length;i++){
			int temp = arr[i];
			int j=i;
			//將需要插入的數(shù)據(jù)與最大的比較，然后逐步向小的方向移動
			while(arr[j-1]>temp){
				arr[j]=arr[j-1];
				j--;
				if(j<=0){
					break;
				}
			}
			arr[j] = temp;
		}
		return arr;
	}
	
	/**
	 * 插入排序 使用for循環(huán)
	 * @param arr
	 * @return
	 */
	public static int[] doInsertSort_for(int[] arr) {
		int length = arr.length;
		for (int i = 1; i < length; i++) {
			int temp = arr[i];
			int j;
			for (j = i; j > 0; j--) {
				if (arr[j - 1] > temp) {
					arr[j] = arr[j - 1];
				} else {
					// 如果當前的數(shù)，不小前面的數(shù)，那就說明不小于前面所有的數(shù)，
					// 因為前面已經(jīng)是排好了序的，所以直接通出當前一輪的比較
					break;
				}
			}
			arr[j] = temp;
		}

		return arr;
	}

	/**
	 * 選擇排序
	 * @param arr
	 * @return
	 */
	public static int[] doChooseSort(int[] arr) {
		int length = arr.length;
		int temp;
		for (int i = 0; i < length; i++) {
			temp = arr[i];
			int j;
			int smallestLocation = i;// 最小數(shù)的下標
			for (j = i + 1; j < length; j++) {
				if (temp > arr[j]) {
					temp = arr[j];// 取出最小值
					smallestLocation = j;// 取出最小值所在的下標
				}
			}
			//選出了最小的數(shù)據(jù)，然后放在smallestLocation的位置，循環(huán)之后只是最后交換一次
			arr[smallestLocation] = arr[i];
			arr[i] = temp;
		}
		return arr;
	}

	/**
	 * 冒泡排序
	 * @param arr
	 * @return
	 */
	public static int[] doBubbleSort(int[] arr) {
		int length = arr.length;
		for (int i = 0; i < length; i++) {

			for (int j = i + 1; j < length; j++) {
				int temp;
				//比較相鄰的下一個數(shù)據(jù)，如果相等則交換（交換多次，與選擇排序不一樣）
				if (arr[i] > arr[j]) {
					temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}

		}
		return arr;
	}

}

    

?

備注：對于static修飾的方法而言，則可以使用類來直接調(diào)用該方法， 如果在static修飾的方法中使用this關(guān)鍵字，則這個關(guān)鍵字就無法指向合適的對象 。所以static修飾的方法中是不能使用this引用的，由于static修飾的方法不能使用this引用，所以static修飾的方法不能訪問不使用static修飾的普通成員。

因此java語法規(guī)定： 靜態(tài)成員不能直接訪問非靜態(tài)成員