数组排序

1.冒泡排序

	/**
	 * 冒泡排序
	 * a.对于一个长度为length的数组numbers
	 * b.比较相邻的两个元素，如果左边大于右边，则互换。
	 * c.从0到length比较所有相邻元素，则最后一个是最大值。
	 * d.从0到length－1重复b操作,直到从0到1为止。则最后的结果为从小到大排序的数组。
	 * 
	 */
	
	/**
	 * 由小到大
	 * @param numbers
	 */
	private static void sortOne(int[] numbers){
		int length = numbers.length;
		for(int i = 0; i < length; i++){
			for(int j = 0; j < length - 1 - i; j++){
				if(numbers[j] > numbers[j + 1]){
					int temp = numbers[j];
					numbers[j] = numbers[j + 1];
					numbers[j + 1] = temp;
				}
			}
		}
	}
	
	/**
	 * 由大到小
	 * @param numbers
	 */
	private static void sortTwo(int[] numbers){
		int length = numbers.length;
		for(int i = 0; i < length; i++){
			for(int j = 0; j < length - 1 - i; j++){
				if(numbers[j] < numbers[j + 1]){
					int temp = numbers[j];
					numbers[j] = numbers[j + 1];
					numbers[j + 1] = temp;
				}
			}
		}
	}

2.快速排序

public class quickSort {
	public static void main(String[] args) {
		int[] numbers = {3, 1, 5, 9, 2, 4, 8, 1, 7, 3};
		sort(numbers, 0, numbers.length - 1);
		for(int i = 0; i < numbers.length; i++){
			System.out.print(numbers[i] + ",");
		}
	}
	
	/**
	 * 快速排序
	 * a.对于数组numbers，取第一个数作为分割位。
	 * b.将大于m的放到左边，将小于m的放到右边
	 * c.然后分别将m左边的按照ab操作，m右边的也按照ab操作
	 * d.直到分割到不可再分割
	 * 
	 */

	/**
	 * 将数组分割，获取最后分割后的位置
	 * @param numbers
	 * @param low
	 * @param high
	 * @return
	 */
	private static int getMiddle(int[] numbers, int low, int high){
		int temp = numbers[low];
		while(low < high){
			//取low位置的值temp与high比较，若temp小于等于high位置值，则比较high--位
			//直到low >= high 或 high位置值大于temp终止循环
			while(low < high && numbers[high] >= temp){
				high --;
			}
			//high位置的值赋值给low位置
			numbers[low] = numbers[high];
			
			//取low位值与temp比较，若temp大于等于low位置值，则比较low++位
			//直到low >= high 或 low位置值大于temp终止循环
			while(low < high && numbers[low] <= temp){
				low ++;
			}
			//low位置值赋值给high位
			numbers[high] = numbers[low];
		}
		//low >= high时到此步，然后将temp的值赋给low位置，此时low为分割位
		numbers[low] = temp;
		return low;
	}

	/**
	 * 排序
	 * @param numbers
	 * @param low
	 * @param high
	 */
	private static void sort(int[] numbers, int low, int high){
		if(low < high){
			int middle = getMiddle(numbers, low, high);
			//分割数组进行再排序
			sort(numbers, low, middle - 1);
			sort(numbers, middle + 1, high);
		}
	}
}

3.选择排序

	/**
	 * 选择排序
	 * 遍历数组，获取最小值位置k，然后交换0位置与k位置值
	 * 遍历数组，获取最小值位置k，然后交换1位置与k位置值
	 * ....
	 * 遍历数组，获取最小值位置k，然后交换length - 1位置与k位置值
	 * @param numbers
	 */
	public static void selectSort(int[] numbers){
		int length = numbers.length;
		//循环从0到length
		for(int i = 0; i < length; i++){
			//k为最小值的position
			int k = i;
			//循环从legth－1 到 i
			for(int j = length - 1; j > i; j --){
				//如果j位置的值小于k位置的值，则j为最小值位置，k＝j
				if(numbers[j] < numbers[k]){
					k = j;
				}
			}
			//将最小值添加到i位置
			if(i != k){
				int temp = numbers[i];
				numbers[i] = numbers[k];
				numbers[k] = temp;
			}	
		}
	}

4.插入排序

	/**
	 * 插入排序
	 * a.从第一个元素开始
	 * b.依次取出下一个元素temp，在已经排序的元素序列中从后向前扫描
	 * c.如果已排序元素大于temp，则已排序元素后移到下一位置
	 * d.重复c直到已排序的元素小于或者等于temp
	 * e.将新元素插入到此位置中
	 * @param numbers
	 */
	private static void sort(int[] numbers){
		int len = numbers.length;
		int j = 0;
		for(int i = 1; i < len; i ++){
			int temp = numbers[i];
			for(j = i; j > 0 && temp < numbers[j - 1]; j--){
				numbers[j] = numbers[j - 1];
			}
			numbers[j] = temp;
		}
	}