Java基础 |数组排序

冒泡排序

他排序数组的过程中总将较小的数往前排，较大的数往后放，类似水中气泡往上升的动作，所以叫冒泡排序。
基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把较大的元素移动到数组后面（交换两个元素）。
用两个循环来实现：一个循环用来控制排序的轮次，另一个用来做交换。
而且每次轮次需要排序的次数也会少一次，因为每一轮都会把最大的数字放到最后一位去。

冒泡排序的时间复杂度 是O(n2)。

public class BubbleSort {
	public static void main(String[] args) {
		int[] array = {63,4,24,1,3,15};
		BubbleSort sorter = new BubbleSort();
		sorter.sort(array);
		for (int i=0;i<array.length;i++) {
			System.out.print(array[i]+" ");
			
		}
	}
	public void sort(int[] array) {
		for(int i=1;i<array.length;i++) {
			for (int j=0;j<array.length-i;j++) {
				if (array[j]>array[j+1]) {
					int a = array[j];
					array[j] = array[j+1];
					array[j+1] = a;
				}
			}
		}
	}
}

直接选择排序

将指定排序位置元素与其他元素分别对比，交换位置，所以是把满足条件的元素与指定的排序位置交换（比如从最后一个元素开始排序），知道整个数组排序。

也是双循环，第一个循环控制几个轮次，第二个循环来找最大值。
直接选择的时间复杂度是O(N log(N))。

public class SelectSort {

	public static void main(String[] args) {
		int[] array = {63,4,24,1,3,15};
		SelectSort sorter = new SelectSort();
		sorter.sort(array);
		for (int i=0;i<array.length;i++) {
			System.out.print(array[i]+" ");
		}
	}
	public void sort(int[] array) {
		int m;
		//需要几个轮次，每个轮次都找最大值
		for (int i=1; i<array.length;i++) {
			m = 0;
			for (int j=1; j<=array.length-i;j++) {
				if (array[j]>array[m]) {
					m = j;
				}
			}
			int a = array[m];
			array[m] = array[array.length-i];
			array[array.length-i] = a;
		}
	}
}

反转排序

以相反的顺序把数组重新排序，实现办法是第一个元素和最后一个交换，第二个和倒数第二个交换，一直到全部交换。

public class ReverseSort {

	public static void main(String[] args) {
		int[] array = {10,20,30,40,50,60};
		ReverseSort sorter = new ReverseSort();
		sorter.sort(array);
		for (int i=0;i<array.length;i++) {
			System.out.print(array[i]+" ");
		}
	}
	public void sort(int[] array) {
		int len = array.length;
		for (int i=0;i<len/2;i++) {
			int a = array[i];
			array[i] = array[len-1-i];
			array[len-1-i] = a;
		}
	}
}