java 四个数字组合 java四个数字排序

package com.test;
public class Sort {
public static void main(String[] args) {

	int numbers[] = { 3, 7, 5, 1, 67, 9, 2, 34, 12, 45 };
	// 1.插入排序
	//insertSort(numbers);

	// 2.选择排序
	// selectSort(numbers);

	// 3.冒泡排序
	bubbleSort(numbers);

	// 4.快速排序

	//quickSort(numbers,0,9);
}


// 1. 插入排序 时间复杂度为O(n^2)
//	排序方法	平均时间复杂度情况	最好情况	最坏情况	空间复杂度	稳定性
//	插入排序	O(n2)			O(n)	O(n2)	O(1)	稳定
// 	假定第一个元素有序。
//	取一个临时变量存放第二个元素的值。第二个元素与第一个元素比较，如果第二个元素大于第一个元素，两个元素交换位置，否者，不做移动。
//	将临时变量的值改为第三个元素的值。第三个元素与第二个比较，如果小于第二个，将第二个元素向右移动，再与第一个元素比较，如果小于第一个，将第一个元素向右移，最后将临时变量的值放入第一个元素位置。
//	3	7	5	1	67	9	2	34	12	45	(最初数组)
//	3	7	5	1	67	9	2	34	12	45	(i=1循环后)	temp=7,7>3不做移动
//	3	5	7	1	67	9	2	34	12	45	(i=2循环后)	temp=5,5<7,7向右移动，5>3，3不移动，把5放入空的位置，即7原来的位置
//	1	3	5	7	67	9	2	34	12	45	(i=3循环后)
//	1	3	5	7	67	9	2	34	12	45	(i=4循环后)
//	1	3	5	7	9	67	2	34	12	45	(i=5循环后)
//	1	2	3	5	7	9	67	34	12	45	(i=6循环后)
//	1	2	3	5	7	9	34	67	12	45	(i=7循环后)
//	1	2	3	5	7	9	12	34	67	45	(i=8循环后)
//	1	2	3	5	7	9	12	34	45	67	(i=9循环后)
public static void insertSort(int[] numbers) {
	int size = numbers.length;

	for (int i = 1; i < size; i++) {

		int temp = numbers[i]; // 保存每次需要插入的那个数
		
		int j;

		for (j = i; j > 0 && numbers[j - 1] > temp; j--) {
			numbers[j] = numbers[j - 1]; 	//把大于临时变量temp的数往后移动，不大于就不移动，最后空的位置就是temp的位置
		}

		numbers[j] = temp; // 将temp放入这个位置
	}
}
// 2.选择排序
// 假设第一个数是已经排序好的数,从后面的元素中找到最小的数与之交换.
//	3	7	5	1	67	9	2	34	12	45	(最初数组)	
//	2	7	5	1	67	9	3	34	12	45	(i=0时，找到2比3小，交换)
//	1	7	5	2	67	9	3	34	12	45	(i=0时，又找到1比2小，再次交换)

//	1	7	5	2	67	9	3	34	12	45	(i=0循环后)
//	1	2	5	3	67	9	7	34	12	45	(i=1循环后)
//	1	2	3	5	67	9	7	34	12	45	(i=2循环后)
//	1	2	3	5	67	9	7	34	12	45	(i=3循环后)
//	1	2	3	5	7	9	12	34	45	67	(i=4循环后)
//	1	2	3	5	7	9	12	34	45	67	(i=5循环后)
//	1	2	3	5	7	9	12	34	45	67	(i=6循环后)
//	1	2	3	5	7	9	12	34	45	67	(i=7循环后)
//	1	2	3	5	7	9	12	34	45	67	(i=8循环后)
//	1	2	3	5	7	9	12	34	45	67	(i=9循环后)
public static void selectSort(int[] numbers) {
	int size = numbers.length, temp;
	for (int i = 0; i < size; i++) {
		for (int j = size - 1; j > i; j--) {
			if (numbers[j] < numbers[i]) {
				temp = numbers[i];
				numbers[i] = numbers[j];
				numbers[j] = temp;
			}
		}
	}
}

// 3.冒泡排序
//将自己与自己右边的一个数比较大小,如果大于右边的数,两个数交换位置,否则不交换。
//第一次外层循环结束,会找到最大的数,且被交换到最后位置
//第二次外城循环结束,会找到第二大的数,且被交换到倒数第二位置。
//i表示外城循环，j表示内层循环
//	3	7	5	1	67	9	2	34	12	45	(最初数组)
//	3	7	5	1	67	9	2	34	12	45	(内层循环,j=0时，3和7不交换)
//	3	5	7	1	67	9	2	34	12	45	(内层循环,j=1时，7和5交换)
//	3	5	1	7	67	9	2	34	12	45	(内层循环,j=2时，7和1交换)
//	3	5	1	7	67	9	2	34	12	45	(内层循环,j=3时，7和67不交换)
//	3	5	1	7	9	67	2	34	12	45	(内层循环,j=4时，67和9交换)
//	3	5	1	7	9	2	67	34	12	45	(内层循环,j=5时，67和2交换)
//	3	5	1	7	9	2	34	67	12	45	(内层循环,j=6时，67和34交换)
//	3	5	1	7	9	2	34	12	67	45	(内层循环,j=7时，67和12交换)
//	3	5	1	7	9	2	34	12	45	67	(内层循环,j=8时，67和45交换)
//(第一次循环结束，找到最大数67，被交换到最后位置)	
	
//	3	5	1	7	9	2	34	12	45	67	(i=0循环后)
//	3	1	5	7	2	9	12	34	45	67	(i=1循环后)
//	1	3	5	2	7	9	12	34	45	67	(i=2循环后)
//	1	3	2	5	7	9	12	34	45	67	(i=3循环后)
//	1	2	3	5	7	9	12	34	45	67	(i=4循环后)
//	1	2	3	5	7	9	12	34	45	67	(i=5循环后)
//	1	2	3	5	7	9	12	34	45	67	(i=6循环后)
//	1	2	3	5	7	9	12	34	45	67	(i=7循环后)
//	1	2	3	5	7	9	12	34	45	67	(i=8循环后)
private static void bubbleSort (int[] numbers) {
	int size=numbers.length;
	for (int i = 0; i < size-1; i++) {//外层循环控制排序多少趟
		
		for (int j = 0; j < size-1-i; j++) {//内层循环控制没趟排序多少次
			if(numbers[j]>numbers[j+1]) {
				int temp=numbers[j];
				numbers[j]=numbers[j+1];
				numbers[j+1]=temp;
			}
		}
	}
}


//4.快速排序
//1将第一个数存入一个临时变量,作为基准数,
//2从后往前找一个比基准数小的数(记住该数的位置,我们用R表示),将该数的值放入基准数位置
//3再从左往右找一个比基准数大的值(记住该数的位置,我们用L表示),将该数的值放入上一步所所获得的R的位置
//4重复第二步和第三步
//最后L=R,结束该次循环,此时将基准数放入L（R）位置。这时基准数左边的数都比基准数小,右边的数都比基准数大。
//把基准数左边的数看作一个新的数组,重复1,2,3,4 步骤,把基准数右边的数看作一个新的数组,重复1,2,3,4。(递归)
//	3	7	5	1	67	9	2	34	12	45		(最初数组)
//												L	R
//	3	7	5	1	67	9	2	34	12	45		0	9
//	2	7	5	1	67	9	2	34	12	45		0	6
//	2	7	5	1	67	9	7	34	12	45		1	6
//	2	1	5	1	67	9	7	34	12	45		1	3
//	2	1	5	5	67	9	7	34	12	45		2	3
//	2	1	5	5	67	9	7	34	12	45		2	2
//	2	1	5	5	67	9	7	34	12	45		2	2

//	2	1	3	5	67	9	7	34	12	45		2	2(第一次二分结束，以3为中心分成左右两个数组)

private static void quickSort(int[] numbers,int l,int r) {
	int start=l;
	int end=r;
	
	if (l >= r) return;
	int key = numbers[l];
	while (l<r) {
		while (l < r && key <= numbers[r])
			r -= 1;
		numbers[l]=numbers[r];
		
		while (l < r && key >= numbers[l])
			l += 1;
		numbers[r] = numbers[l];
		
	}
	numbers[l]=key;
	
	quickSort(numbers, start, l - 1);
	quickSort(numbers, l + 1, end);
	
}}