选择排序、冒泡排序

选择排序

思路

选择排序开始的时候，我们扫描整个列表，找到它的最小元素，然后和第一个元素交换，将最小元素放在它在有序表中的最终位置。然后我们从第二个元素开始扫描列表，找到最后n-1个元素中的最小元素，再和第二个元素交换位置，把第二小的元素放在它的最终位置

伪代码：

SelectionSort(A[0...n-1])
	//该算法用选择排序对给定的数组排序
	//输入：一个可排序的数据A[0...n-1]
	//输出：升序排序的数组A[0...n-1]
	for i <- 0 to n-2 do
		min <- i
		for j <- i+1 to n-1 do
			if A[j] < A[min] 
				min <- j
		swap A[i] and A[min]

显然，对于任何输入来说，选择排序都是一个时间复杂度为$n^2$的算法。

Java代码实现

public class SelectSort {

    public static void main(String[] args) {
        int[] a = {43,54,3,6,34};
        Sort(a);
        System.out.println(Arrays.toString(a));
    }

    public static void Sort(int[] arr){
        int min = 0;
        int len = arr.length;
        for (int i=0;i<len-1;i++){
            min = i;
            for (int j = i+1;j<len;j++){
                if (arr[j]<arr[min]) min = j;
            }
            int temp = arr[i];
            arr[i] = arr[min];
            arr[min] = temp;
        }
    }
}

结果如下：

冒泡排序

思路

比较表中相邻元素，如果它们是逆序的话，就交换它们的位置。重复多次以后，最终，最大的元素就“沉到”列表的最后一个位置。第二遍操作将第二大的元素沉下去。以此类推，知道第n-1遍操作完成时，该列表就排好序了

伪代码

BubbleSort(A[0...n-1]
	//该算法用冒泡排序对数组A[0...n-1]进行排序
	//输入：一个可排序数组A[0...n-1]
	//输出：升序排列的数组A[0..n-1]
	for i <- 0 to n-2 do
		for j <-0 to n-2-i do
			if A[j+1] < A[j]
				swap A[j] and A[j+1]

Java代码实现

public class BubbleSort {
    public static void main(String[] args) {
        int[] a = {43,54,3,6,34};
        Sort(a);
        System.out.println(Arrays.toString(a));
    }

    public static void Sort(int[] arr){
        int len = arr.length;
        for (int i=0;i<len-1;i++){
            for (int j = 0; j< len-1-i;j++){
                if (arr[j+1]<arr[j]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
}

结果如下：

改进

public static void Sort2(int[] arr){
        int len = arr.length;
        for (int i=0;i<len-1;i++){
        	//添加了change变量，记录是否发生过交换
            boolean change = false;
            for (int j = 0; j< len-1-i;j++){
                if (arr[j+1]<arr[j]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    //发生交换，赋值为true
                    change = true;
                }
            }
            //如果change=false则结束排序
            if (change==false) return;
        }
    }

该改进思路最难理解的大概就是change变量的设置，但是我们不妨回看一下冒泡排序的概念。冒泡排序每一次都会遍历检查逆序的情况，如果相邻元素逆序，则交换两元素，如果某次遍历检查不发生交换，不就是表示已经没有逆序的情况了那吗？自然也就是完成排序了。