是时候该复习一下排序算法了

原创 于 2020-08-11 12:41:44 发布 · 351 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法

本文深入讲解了五种经典的排序算法：选择排序、插入排序、希尔排序、快速排序和归并排序，以及堆排序的实现原理与代码实现。通过具体实例，帮助读者理解每种算法的特点和适用场景。

天行健，君子以自強不息，地勢坤，君子以厚德载物。

最近，我在做题的时候，碰到了一个链表的题目，结果被那个题卡了一个多小时
在这里插入图片描述

哎，数据结构真是白给啊，才学完几个月啊，现在就忘得一点也不剩了
在这里插入图片描述
趁此机会，我打算好好复习一下链表，顺便再看看排序算法

选择排序

package ch2;

import java.util.Arrays;
import java.util.Scanner;

/**
 * @author martin
 * @date 2020/8/10
 **/
public class Selection {
    public static void sort(Comparable[] arr) {
        // 将arr按升序排序
        int N = arr.length;
        for (int i = 0; i < N; i++) {
            int min = i;
            for (int j = i + 1; j < N; j++) {
                if (less(arr[j], arr[min])) {
                    min = j;
                }
            }
            exchange(arr, i, min);
        }
    }
    private static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }
    private static void exchange(Comparable[] arr, int i, int j) {
        Comparable t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
    private static void show(Comparable[] arr) {
        System.out.println(Arrays.toString(arr));
    }
    public static boolean isSorted(Comparable[] arr) {
        // 测试数组元素是否有序
        for (int i = 1; i < arr.length; i++) {
            if (less(arr[i], arr[i-1])) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();
        String[] arr = new String[N];
        for (int i = 0; i < N; i++) {
            arr[i] = scanner.next();
        }
        sort(arr);
        assert isSorted(arr);
        show(arr);
    }
}

插入排序

package ch2;

import java.util.Arrays;
import java.util.Scanner;

/**
 * @author martin
 * @date 2020/8/10
 **/
public class Insertion {
    public static void sort(Comparable[] arr) {
        // 将arr数组按升序排序
        int N = arr.length;
        for (int i = 1; i < N; i++) {
            for (int j = i; j > 0 && less(arr[j], arr[j-1]); j--) {
                exchange(arr, j, j-1);
            }
        }
    }
    private static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }
    private static void exchange(Comparable[] arr, int i, int j) {
        Comparable t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
    private static void show(Comparable[] arr) {
        System.out.println(Arrays.toString(arr));
    }
    public static boolean isSorted(Comparable[] arr) {
        // 测试数组元素是否有序
        for (int i = 1; i < arr.length; i++) {
            if (less(arr[i], arr[i-1])) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();
        String[] arr = new String[N];
        for (int i = 0; i < N; i++) {
            arr[i] = scanner.next();
        }
        sort(arr);
        assert isSorted(arr);
        show(arr);
    }
}

希尔排序

package ch2;

import java.util.Arrays;
import java.util.Scanner;

/**
 * @author martin
 * @date 2020/8/10
 **/
public class Shell {
    public static void sort(Comparable[] arr) {
        int N = arr.length;
        int h = 1;
        while (h < N / 3) {
            h = 3 * h + 1;
        }
        while (h >= 1) {
            for (int i = h; i < N; i++) {
                for (int j = i; j >= h && less(arr[j], arr[j - h]); j-=h) {
                    exchange(arr, j, j - h);
                }
            }
            h /= 3;
        }
    }
    private static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }
    private static void exchange(Comparable[] arr, int i, int j) {
        Comparable t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
    private static void show(Comparable[] arr) {
        System.out.println(Arrays.toString(arr));
    }
    public static boolean isSorted(Comparable[] arr) {
        // 测试数组元素是否有序
        for (int i = 1; i < arr.length; i++) {
            if (less(arr[i], arr[i-1])) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();
        String[] arr = new String[N];
        for (int i = 0; i < N; i++) {
            arr[i] = scanner.next();
        }
        sort(arr);
        assert isSorted(arr);
        show(arr);
    }
}

快速排序

package ch2;

import java.util.Arrays;
import java.util.Scanner;

/**
 * @author martin
 * @date 2020/8/10
 **/
public class Quick {
    public static void sort(Comparable[] arr) {
        sort(arr, 0, arr.length - 1);
    }
    private static void sort(Comparable[] arr, int low, int high) {
        if (high <= low) {
            return;
        }
        int j = partition(arr, low, high);
        sort(arr, low, j - 1);
        sort(arr, j + 1, high);
    }
    public static int partition(Comparable[] arr, int low, int high) {
        // 切分
        int i = low, j = high + 1;
        Comparable v = arr[low];
        while (true) {
            while (less(arr[++i], v)) {
                if (i == high) {
                    break;
                }
            }
            while (less(v, arr[--j])) {
                if (j == low) {
                    break;
                }
            }
            if (i >= j) {
                break;
            }
            exchange(arr, i, j);
        }
        exchange(arr, low, j);
        return j;
    }
    private static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }
    private static void exchange(Comparable[] arr, int i, int j) {
        Comparable t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();
        String[] arr = new String[N];
        for (int i = 0; i < N; i++) {
            arr[i] = scanner.next();
        }
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

归并排序

package ch2;

import java.util.Arrays;
import java.util.Scanner;

/**
 * @author martin
 * @date 2020/8/10
 **/
public class Merge {
    private static Comparable[] aux; // 归并所需的辅助数组
    private static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }
    public static void sort(Comparable[] arr) {
        aux = new Comparable[arr.length];
        sort(arr, 0, arr.length - 1);
    }
    public static void sort(Comparable[] arr, int low, int high) {
        if (high <= low) {
            return;
        }
        int mid = (low + high) / 2;
        sort(arr, low, mid);
        sort(arr, mid + 1, high);
        merge(arr, low, mid, high);
    }
    public static void merge(Comparable[] arr, int low, int mid, int high) {
        int i = low, j = mid + 1;
        for (int k = low; k <= high; k++) {
            aux[k] = arr[k];
        }
        for (int k = low; k <= high; k++) {
            if (i > mid) {
                arr[k] = aux[j++];
            } else if (j > high) {
                arr[k] = aux[i++];
            } else if (less(aux[j], aux[i])) {
                arr[k] = aux[j++];
            } else {
                arr[k] = aux[i++];
            }
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();
        String[] arr = new String[N];
        for (int i = 0; i < N; i++) {
            arr[i] = scanner.next();
        }
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

堆排序

package ch2;

import java.util.Scanner;

/**
 * @author martin
 * @date 2020/8/11
 **/
public class Heap {
    public static void sort(Comparable[] arr) {
        int N = arr.length - 1;
        for (int k = N / 2; k >= 1; k--) {
            sink(arr, k, N);
        }
        while (N > 1) {
            exchange(arr, 1, N--);
            sink(arr, 1, N);
        }
    }

    private static void sink(Comparable[] arr, int k, int N) {
        // 下沉
        while (2 * k <= N) {
            int j = 2 * k;
            if (j < N && less(arr, j, j + 1)) {
                ++j;
            }
            if (!less(arr, k, j)) {
                break;
            }
            exchange(arr, k, j);
            k = j;
        }
    }

    private static void exchange(Comparable[] arr, int i, int j) {
        Comparable t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

    private static boolean less(Comparable[] arr, int i, int j) {
        return arr[i].compareTo(arr[j]) < 0;
    }

    public static void print(Comparable[] arr) {
        System.out.print("[");
        for (int i = 1; i < arr.length; i++) {
            if (i == 1) {
                System.out.print(arr[i].toString());
            } else {
                System.out.print(", " + arr[i].toString());
            }
        }
        System.out.print("]");
        System.out.println();
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        String[] arr = new String[n + 1];
        for (int i = 1; i <= n; i++) {
            arr[i] = scanner.next();
        }
        sort(arr);
        print(arr);
    }
}

在这里插入图片描述
在这里插入图片描述

– 神奇旅程 –

希望文章对您有所帮助，如果有不足之处，还请海涵~

蒟蒻写博客不易，加之本人水平有限，写作仓促，错误和不足之处在所难免，谨请读者和各位大佬们批评指正。
如需转载，请署名作者并附上原文链接，蒟蒻非常感激
名称：虐猫人薛定谔
博客地址：https://liuyuhe.blog.youkuaiyun.com/

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值