java （冒泡、选择、插入）排序

 

 1、冒泡排序 Bubble Sort

 

       最简单的排序方法是冒泡排序方法。这种方法的基本思想是，将待排序的元素看作是竖着排列的“气泡”，较小的元素比较轻，从而要往上浮。在冒泡排序算法中我们要对这个“气泡”序列处理若干遍。所谓一遍处理，就是自底向上检查一遍这个序列，并时刻注意两个相邻的元素的顺序是否正确。如果发现两个相邻元素的顺序不对，即“轻”的元素在下面，就交换它们的位置。显然，处理一遍之后，“最轻”的元素就浮到了最高位置；处理二遍之后，“次轻”的元素就浮到了次高位置。在作第二遍处理时，由于最高位置上的元素已是“最轻”元素，所以不必检查。一般地，第i遍处理时，不必检查第i高位置以上的元素，因为经过前面i-1遍的处理，它们已正确地排好序。这个算法可实现如下。

 

 

2、选择排序 Selection Sort

 

       选择排序的基本思想是：对待排序的记录序列进行n-1遍的处理，第1遍处理是将L[1..n]中最小者与L[1]交换位置，第2遍处理是将L[2..n]中最小者与L[2]交换位置，......，第i遍处理是将L[i..n]中最小者与L[i]交换位置。这样，经过i遍处理之后，前i个记录的位置就已经按从小到大的顺序排列好了。

　　当然，实际操作时，也可以根据需要，通过从待排序的记录中选择最大者与其首记录交换位置，按从大到小的顺序进行排序处理。

 

备注：个人理解冒泡排序是每次和相邻的数据比较之后（如果符合条件）就进行交换；

而选择排序是每次选择最小的，确定之后再做交换，然后依次放在数组的最前或者最后面

 

 

3 、插入排序 Insertion Sort

插入排序的基本思想是，经过i-1遍处理后,L[1..i-1]己排好序。第i遍处理仅将L[i]插入L[1..i-1]的适当位置，使得L[1..i]又是排好序的序列。要达到这个目的，我们可以用顺序比较的方法。首先比较L[i]和L[i-1]，如果L[i-1]≤ L[i]騆[1..i]已排好序，第i遍处理就结束了；否则交换L[i]与L[i-1]的位置，继续比较L[i-1]和L[i-2]，直到找到某一个位置j(1≤j≤i-1)，使得L[j] ≤L[j+1]时为止。
　　 简言之,插入排序就是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置，直到全部插入完毕。插入排序方法分直接插入排序和折半插入排序两种，这里只介绍直接插入排序，折半插入排序留到“查找”内容中进行。
　　图1演示了对4个元素进行直接插入排序的过程，共需要(a),(b),(c)三次插入。

 

 

 

 

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);
	}

	/**
	 * 循环数组
	 * @param arr 需要便利的数组
	 */
	public static void printArr(int[] arr) {
		for (int a : arr) {
			System.out.println(a);
		}
	}

	/**
	 * 插入排序 使用while循环  
	 * @param arr
	 * @return
	 */
	public static int[] doInsertSort_while(int[] arr){
		int length = arr.length;
		//从第一个数组开始，与第零个比较
		for(int i=1;i<length;i++){
			int temp = arr[i];
			int j=i;
			//将需要插入的数据与最大的比较，然后逐步向小的方向移动
			while(arr[j-1]>temp){
				arr[j]=arr[j-1];
				j--;
				if(j<=0){
					break;
				}
			}
			arr[j] = temp;
		}
		return arr;
	}
	
	/**
	 * 插入排序 使用for循环
	 * @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 {
					// 如果当前的数，不小前面的数，那就说明不小于前面所有的数，
					// 因为前面已经是排好了序的，所以直接通出当前一轮的比较
					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;// 最小数的下标
			for (j = i + 1; j < length; j++) {
				if (temp > arr[j]) {
					temp = arr[j];// 取出最小值
					smallestLocation = j;// 取出最小值所在的下标
				}
			}
			//选出了最小的数据，然后放在smallestLocation的位置，循环之后只是最后交换一次
			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;
				//比较相邻的下一个数据，如果相等则交换（交换多次，与选择排序不一样）
				if (arr[i] > arr[j]) {
					temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}

		}
		return arr;
	}

}

 

备注：对于static修饰的方法而言，则可以使用类来直接调用该方法，如果在static修饰的方法中使用this关键字，则这个关键字就无法指向合适的对象。所以static修饰的方法中是不能使用this引用的，由于static修饰的方法不能使用this引用，所以static修饰的方法不能访问不使用static修饰的普通成员。

因此java语法规定：静态成员不能直接访问非静态成员