【Java数据结构】--- 七大排序（交换和归并排序）

乐观学习，乐观生活，才能不断前进啊！！！

我的主页：optimistic_chen

我的专栏：c语言 ，Java

欢迎大家访问~
创作不易，大佬们点赞鼓励下吧~

交换排序

根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动

冒泡排序

通过相邻元素之间的比较和交换，把每一对相邻元素中较小的元素“浮”到前面，较大的元素“沉”到后面。这个过程类似于水中的气泡逐渐冒到水面的过程，因此得名“冒泡排序”

冒泡排序是一个容易理解的排序方式，也是我最早接触的排序方式之一，它会给我们很大信心。

public class BubbleSort {

    // 冒泡排序函数
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) { // 外层循环控制排序趟数
            for (int j = 0; j < n - i - 1; j++) { // 内层循环控制每趟排序多少次
                // 如果当前元素大于下一个元素，则交换它们
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    // 主函数
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        System.out.println("原始数组："+Arrays.toString(arr));

        bubbleSort(arr);

        System.out.println("冒泡排序后的数组："+Arrays.toString(arr));

    }
}

优化：如果在一趟遍历中没有发生任何交换，则说明数组已经有序，此时可以提前结束排序。

public static void optimizedBubbleSort(int[] arr) {
    int n = arr.length;
    boolean flag;
    for (int i = 0; i < n - 1; i++) {
        //标记
        flag = false;
        //交换
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                flag = true;
            }
        }
        // 如果没有发生交换，说明数组已经有序，可以提前结束
        if (!flag) {
            break;
        }
    }
}

总结：逻辑简单，易于理解和实现

· 时间复杂度：最好情况O（n）
``················_` 最差情况O（n^2）
· 空间复杂度：O（1）
· 稳定性：稳定

快速排序

任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止

1. 选择基准值（对于基准值，我一般取第一个数就行了）
2. 按照基准值对数组进行划分
3. 反复对划分序列进行1 2 操作

public class QuickSort {
 
    public static void quickSort(int[] arr, int left, int right) {
        if (left < right) {
            // 找到划分点
            int pivotIndex = partition(arr, left, right);
 
            // 递归地对左右两部分进行快速排序
            quickSort(arr, left, pivotIndex - 1);
            quickSort(arr, pivotIndex + 1, right);
        }
    }
 
    private static int partition(int[] arr, int low, int high) {
        // 选择第一个元素作为基准
        int i = left;
            int j = right;
            int pivot = array[left];
            while (i < j) {
                while (i < j && array[j] >= pivot) {
                    j--;
                }

                while (i < j && array[i] <= pivot) {
                    i++;
                }
                //交换数组中大于基准值的数和小于基准值的数
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        //把基准值放到正确的位置上（i）
        int temp = array[i];
        array[i] = array[left];
        array[left] = temp;
        return i;
        }
 
    public static void main(String[] args) {
        int[] array = {9, 7, 5, 11, 12, 2, 14, 3, 10, 6};
        int n = array.length;
        System.out.println("排序前: "+Arrays.toString(array));
        quickSort(array, 0, n - 1);
 
        System.out.println("排序后: "+Arrays.toString(array));
    }
}

总结：

1. 时间复杂度：O（n*log2 n）
2. 空间复杂度：O（log2 n）
3. 稳定性：不稳定

归并排序

归并排序是建立在归并操作上的一种有效的排序算法。 将已有序的子序列合并，得到完全有序的序列； 即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
            int[] nums = {6,4,2,1,8,5,3,7};          //给定一个数组
            System.out.println("排序前："+Arrays.toString(nums));
            sortArray(nums);       //排序后的数组
            System.out.println("排序后："+Arrays.toString(nums)); //打印输出得到数组
        }

    private static int[] sortArray(int[] nums) {
        int len = nums.length;
        int[] temp = new int[len];
        mergeSort(nums,0,len-1,temp);
        return nums;
    }

    /**
     * 递归函数对nums[left...right]进行归并排序
     * @param nums 原数组
     * @param left 左边的索引
     * @param right 右边记录索引位置
     * @param temp
     */
    private static void mergeSort(int[] nums, int left, int right, int[] temp) {
        if (left == right){//当拆分到数组当中只要一个值的时候，结束递归
            return;
        }
        int mid = (left+right)/2;   //找到下次要拆分的中间值
        mergeSort(nums,left,mid,temp);//记录树左边的
        mergeSort(nums,mid+1,right,temp);//记录树右边的

        //合并两个区间
        for (int i = left; i <= right; i++) {
            temp[i] = nums[i]; 
//temp就是辅助列表，新列表的需要排序的值就是从辅助列表中拿到的
        }
        int i = left;       //给辅助数组里面的值标点
        int j = mid +1;
        for (int k = left; k <= right ; k++) {//k 就为当前要插入的位置
            if (i == mid + 1){
                nums[k] = temp[j];
                j++;
            }else if (j == right+1){
                nums[k] = temp[i];
                i++;
            }
            else if (temp[i] <= temp[j]){
                nums[k] = temp[i];
                i++;
            }else {
                nums[k] = temp[j];
                j++;
            }
        }
    }
}

总结：分治算法

1. 分解：把一个大问题拆成小问题；
2. 解决：逐个解决小问题；
3. 合并：再把这些小问题的结果组合起来组成大问题的解
4. 时间复杂度：O(N*logN)
5. 空间复杂度：O(N)
6. 稳定性：稳定

完结

好了，到这里Java语法部分就已经结束了~
如果这个系列博客对你有帮助的话，可以点一个免费的赞并收藏起来哟~
可以点点关注，避免找不到我~ ，我的主页：optimistic_chen
我们下期不见不散~~Java

下期预告: 【Java数据结构】- - -Map