杠上数据结构 - 排序

杠上数据结构 - 排序

• 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
• 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。
• 时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
• 空间复杂度：是指算法在计算机

冒泡排序

每次 比较相邻 的两个元素，后一个元素值小于前一个元素值（升序），则交互位置，n 个元素需要比较 n-1 趟，每一趟需要比较 (n-当前第几趟) 次。
如数组 {23, 1, 98,4,18,3 }

第一趟：
第一次比较：23 > 1 交换位置： 1, 23, 98, 4, 18, 3
第二次比较：23 < 98 位置不变： 1, 23, 98, 4, 18, 3
第三次比较：98 > 4 交换位置： 1, 23, 4, 98，18, 3
第四次比较：98 > 18 交换位置： 1, 23, 4，18, 98，3
第五次比较：98 > 3 交换位置： 1, 23, 4，18, 3，98
第一趟比较完，最大的元素下移到最后位置。

第二趟：
第一次比较：1 < 23 位置不变： 1, 23, 4，18, 3，98
第二次比较：23 > 4 交换位置： 1, 4，23, 18, 3，98
第三次比较：23 > 18 交换位置： 1, 4, 18，23, 3，98
第四次比较：23 > 3 交换位置： 1, 4, 18，3, 23，98
第二趟比较完，最大的两个元素排到了最后两个位置上了。

第三趟：
第一次比较：1 < 4 位置不变： 1, 4, 18，3, 23，98
第二次比较：4 > 18 位置不变： 1, 4, 18，3, 23，98
第三次比较：18 > 3 交换位置： 1, 4, 3，18, 23，98
第三趟比较完，最大的三个元素排到了最后三个位置上了。

第四趟：
第一次比较：1 < 4 位置不变： 1, 4, 3，18, 23，98
第二次比较：4 > 3 交换位置： 1, 3, 4，18, 23，98
第四趟比较完，最大的四个元素排到了最后四个位置上了。

第五趟：
第一次比较：1 < 3 位置不变：1, 3, 4，18, 23，98
第五趟比较完，最大的五个元素排到了最后五个位置上了。

常规写法

private void bubbleSort(int[] array) {
        for(int i = 0; i < array.length - 1; i++) {
            System.out.println("第 " + i + " 趟");
            for(int j = 0; j < array.length - i - 1;j++) {
                if(array[j] > array[j+1]) {
                    int temp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = temp;
                }
            }
        }
        print(array);
    }
    
bubbleSort(new int[]{1,2,3,4,5,6,9,8});    

"第 0 趟" : 
"第 1 趟" : 
"第 2 趟" : 
"第 3 趟" : 
"第 4 趟" : 
"第 5 趟" : 
"第 6 趟" : 
[1, 2, 3, 4, 5, 6, 8, 9]

优化一： 标志位减少比较趟数

条件： 假如有序列 {1, 2, 3, 4, 5, 6, 7, 8, 10, 9} , 第一趟排序将 10 和 9 交换位置，此时序列为 {1, 2, 3, 4, 5, 6, 7, 8, 9, 10} 已经有序，接下来的 8 趟排序就是多余的，什么也没做。所以我们可以加一个标志位，如果某一趟中没有交换过元素，则说明此时已经有序了，不用再比较剩下的趟数。

private void bubbleSort(int[] array) {
        for(int i = 0; i < array.length - 1; i++) {
            System.out.println("第 : "  + i  + " 趟 ");
            // 标记这一趟中，有没有元素交换位置，如果这一趟中没有元素交换位置，则说明此时已经有序了，后面的 n-i-1 趟就不需要再走了。
           boolean changed = false;
            for(int j = 0; j < array.length - i - 1;j++) {
                if(array[j] > array[j+1]) {
                    int temp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = temp;
                    changed = true;
                }
            }
            if(!changed) {
                break;
            }
        }
        print(array);
    }
    // 调用
   bubbleSort(new int[]{1,2,3,4,5,6,9,8});             
            

第 0 趟
第 1 趟
[1, 2, 3, 4, 5, 6, 8, 9]

选择排序

private void sortSelect(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        int min = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[min]) {
                min = j;
            }
        }
        if (min != i) {
            int temp = arr[i];
            arr[i] = arr[min];
            arr[min] = temp;
        }
    }
    System.out.println(Arrays.toString(arr));
}