冒泡排序与选择排序【排序算法篇】

冒泡排序

邻居根据规则交换，将较小的或较大的值沉下去，形成升序数组或降序数组。
以下是升序数组的案例：

public static void BubbleSort(int [] arr){

     int temp;//临时变量
     for(int i=0; i<arr.length-1; i++){   //表示趟数，一共arr.length-1次。
     
         for(int j=0; j<arr.length-1-i; j++){	//每一趟，都将使当前区间的最大值在当前区间的末尾，即将较小的值浮上去，最大的值沉下去
         
//当前节点值比下个节点值大，交换。
//那么之后比较的就是现在两者中较大的那个值。
//那么最后在arr.length-1-i的位置上一定是当前区间内的最大值
             if(arr[j] > arr[j+1]){	
                 temp = arr[j];
                 arr[j] = arr[j+1];
                 arr[j+1] = temp;
             }
         }
     }
 }

案例:
【4、3、5、2、1】

【3、4、5、2、1】
【3、4、5、2、1】
【3、4、2、5、1】
【3、4、2、1、5】最后5到了末尾，比5小的数浮在了它的上面，接下来的排序区间变为【3、4、2、1】

---

选择排序

创建一个变量，遍历区间，变量将保存当前区间的最小或最大值的索引。当前区间遍历结束，利用索引将最小或最大值与当前区间头值进行交换。若当前区间的最小或最大值就是当前区间头值则不用交换。

    public void SelectSort() {
        int[] arr = new int[]{3, 4, 5, 2, 1};
        int lenth = arr.length - 1;
        for (int i = 0; i < lenth - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j <= lenth; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            if (minIndex != i) {
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
        for (int i : arr) {
            System.out.println(i);
        }
    }

案例:
【3、4、5、2、1】minIndex=0
【3、4、5、2、1】minIndex=0
【3、4、5、2、1】minIndex=0
【3、4、5、2、1】minIndex=3
【3、4、5、2、1】minIndex=4
第一躺内循环结束时：i=0，minIndex=4 则 arr[0] 与 arr[4] 交换
【1、4、5、2、3】，之后的排序区间为【4、5、2、3】
之后，以此类推

$以上两种排序它们的时间复杂度都为$O(n^2)$，空间复杂度为O(1)$