数据结构--排序

于 2025-01-15 11:25:23 发布
阅读量532 收藏 4
点赞数 4
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2301_80176093/article/details/144174328
版权

目录

常见的排序算法

插入排序

1.直接插入排序

展示部分代码执行流程

代码展示

2.希尔排序( 缩小增量排序 )

展示部分代码执行流程

代码1--已经定义gap的变量

代码2--未定义gap

选择排序

展示部分代码执行流程

代码展示

交换排序

冒泡排序（省略）

选择排序（省略）

快速排序

展示部分代码执行流程

代码展示

归并排序

展示部分代码执行流程

代码展示

常见的排序算法

插入排序

基本思想：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列

1.直接插入排序

展示部分代码执行流程

代码展示
public class Main {
    public static void main(String[] args) {

        int arr[] = {1,4,6,3,8};
        insert(arr);
        print(arr);
    }

    public static void insert(int[] arr){
        int n = arr.length;
        for (int i = 1; i < n; i++) {
            int key = arr[i];
            int j = i-1;

            while(j>0 && arr[j] > key){
                arr[j+1] = arr[j];
                j = j-1;
            }
            arr[j+1] = key;
        }
    }

    public static void print(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

2.希尔排序( 缩小增量排序 )

展示部分代码执行流程

代码1--已经定义gap的变量
public class Main {
    public static void main(String[] args) {

        int arr[] = {1,5,7,2,4,8,9,52};
        SellSort(arr);
        //print(arr);
    }

    public static void SellSort(int[] arr){
        int gap = 2;
        int j = gap + 1;
        int i =0;

        /*while(i <= arr.length / 2){
            if(arr[i] > arr[j]){
                swap(arr,i,j);
            }
            i++;
            j++;
            //输出每一趟的修改后的结果
            for (int d = 0; d < arr.length; d++) {
                System.out.print(arr[d]+" ");
            }
            System.out.println();
        }*/

        //那么如果我只想让你只输出发生修改了的结果
        //我们可以利用设计标志去记录这个情况
        //将这个包含在循环里面，如果这个情况发生则输出
        while(i <= arr.length / 2){
            if(arr[i] > arr[j]){
                swap(arr,i,j);
                //输出发生修改后的结果
                for (int d = 0; d < arr.length; d++) {
                    System.out.print(arr[d]+" ");
                }
                System.out.println();
            }
            i++;
            j++;
        }
    }

    /*public static void swap(int[] arr,int n,int k){
        int temp = arr[n];
        arr[n] = arr[k];
        arr[k] = temp;
    }*/

    public static void swap(int[] arr,int n,int k){
        int temp = arr[n];
        arr[n] = arr[k];
        arr[k] = temp;
    }


    public static void print(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}
代码2--未定义gap
public class Main {
    public static void main(String[] args) {
        int arr[] = {1, 5, 7, 2, 4, 8, 9, 52};
        sellSort(arr);
    }

    // 希尔排序的实现
    public static void sellSort(int[] arr) {
        int n = arr.length;

        // 初始化 gap，并逐步减小 gap
        for (int gap = n / 2; gap > 0; gap /= 2) {
            // 对当前步长进行插入排序
            for (int i = gap; i < n; i++) {
                int key = arr[i];
                int j = i;
                // 插入排序逻辑：比较并交换符合当前 gap 的元素
                while (j >= gap && arr[j - gap] > key) {
                    arr[j] = arr[j - gap];
                    j -= gap;
                }
                arr[j] = key;
            }

            // 每次交换后输出数组
            System.out.println("After gap = " + gap + ":");
            print(arr);
        }
    }

    // 打印
    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

选择排序

展示部分代码执行流程

代码展示
public class Main {
    public static void main(String[] args) {
        int arr[] = {1, 5, 7, 2, 4, 8, 9, 52};
        selectSort(arr);
        print(arr);
    }

    public static void selectSort(int[] arr) {
        int n = arr.length;

        //i 的边界是 n-1，表示每次排序时的基准位置，直到倒数第二个元素
        //就相当于图示的前面一个min，后面比较的是出了min的部分
        for (int i = 0; i < n - 1; i++) {
            int min = i;

            //j 的边界是 n，表示遍历从 i+1 到数组末尾的所有元素，找到最小值并与当前基准位置的元素交换
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[min]) {
                    min = j;
                }
            }

            if (min != i) {
                swap(arr, i, min);
            }
        }
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

交换排序

冒泡排序（省略）
选择排序（省略）

快速排序
展示部分代码执行流程

代码展示

// 快速排序
public class Test3 {
    public static void main(String[] args) {
        int[] arr = {85, 7, 2, 4, 1, 9, 5, 2};
        quickSort(arr, 0, arr.length - 1);
        print(arr);
    }

    // 快速排序
    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            // 获取基准元素的正确位置
            int pi = partition(arr, low, high);
            // 对基准元素左侧和右侧部分递归进行排序
            quickSort(arr, low, pi - 1);
            quickSort(arr, pi + 1, high);
        }
    }

    // 分区操作，返回基准元素的正确位置
    public static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];  // 选择最后一个元素作为基准元素
        int i = low - 1;  // i 是已排序部分的指针

        for (int j = low; j < high; j++) {
            if (arr[j] < pivot) {  // 如果当前元素小于基准元素
                i++;
                // 交换 arr[i] 和 arr[j]
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }

        // 将基准元素放到正确的位置（i + 1）
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;

        return i + 1;  // 返回基准元素的索引
    }

    // 打印数组
    public static void print(int[] arr) {
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

归并排序

展示部分代码执行流程

1.逐级拆分这个数据，每次都是整体的一半

2.当拆分为单个数据的时候，就可以停止拆分

3.开始进行比大小的合并

代码展示

public class Test4 {

    public static void main(String[] args) {
        int[] arr = {85,7,2,4,1,9,52,66};

        mergeSort(arr);
        print(arr);
    }

    public static void mergeSort(int[] arr){

        //数组可以拆分
        if(arr.length > 1){
            int mid = arr.length / 2;
            int[] left = new int[mid];
            int[] right = new int[arr.length - mid];

            //整个数组切片，存入左边数组
            for (int i = 0; i < mid; i++) {
                left[i] = arr[i];
            }

            //右边
            for (int i = mid; i < arr.length; i++) {
                right[i-mid] = arr[i];
            }

            //开始反复分割，直至剩余个数为1
            mergeSort(left);
            mergeSort(right);

            //分割完毕开始合并
            merge(left,right,arr);
        }
    }

    public static void merge(int[] left,int[] right,int[] arr){

        int i = 0,j = 0,k = 0;

        //当数组长度为0，则说明该数组已经排列完毕
        while (i < left.length && j < right.length){
            if(left[i] <= right[i]){
                arr[k++] = left[i++];
            }else {
                arr[k++] = right[i++];
            }
        }

        //如果另一个数组有剩余的情况，那么直接放入arr
        while (i < left.length){
            arr[k++] = left[i++];
        }

        while (j < right.length){
            arr[k++] = right[i++];
        }

    }

    public static void print(int[] arr) {
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

2301_80176093
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值