排序算法--Java语言

已于 2023-07-28 13:20:56 修改
阅读量49 收藏
点赞数
分类专栏： 算法 文章标签： 排序算法 java 算法
于 2022-11-19 22:17:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bingbingyihao/article/details/127940462
版权

排序算法--Java语言

排序算法性能比较

在Java语言下进行测试，分别测试 1 000、10 000、100000、100 0000、1000 0000 数据下的排序所需性能

平方级的算法对比

直接插入、二分插入、冒泡、选择
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

nlogn级别的：希尔排序、快速排序、堆排序、归并排序
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

N级别的基数排序
在这里插入图片描述

排序说明

默认排序均排序成升序序列，使用 int 类型数组

测试主程序

package sort;

/**
 * @author bbyh
 * @date 2022/11/19 0019 17:12
 * @description
 */
public class PerformanceTest {
    private static final int LENGTH = 50;

    public static void main(String[] args) {
        int[] arr = new int[LENGTH];
        for (int i = 0; i < LENGTH; i++) {
            arr[i] = (int) (Math.random() * LENGTH);
        }

        long start = System.currentTimeMillis();
        RadixSort.radixSort(arr, arr.length);
        long end = System.currentTimeMillis();
        System.out.println(end - start);

        printArr(arr);
    }

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

插入式排序

插入排序

package sort;

/**
 * @author bbyh
 * @date 2022/11/19 0019 17:11
 * @description
 */
public class InsertSort {
    public static void insertSort(int[] arr, int length) {
        int i, j, index;
        int temp;
        for (i = 0; i < length; i++) {
            temp = arr[i];
            index = i;
            for (j = i - 1; j >= 0; j--) {
                if (temp < arr[j]) {
                    index = j;
                } else {
                    break;
                }
            }
            if (index != i) {
                for (j = i - 1; j >= index; j--) {
                    arr[j + 1] = arr[j];
                }
                arr[index] = temp;
            }
        }
    }
}

二分插入排序

package sort;

/**
 * @author bbyh
 * @date 2022/11/19 0019 18:21
 * @description
 */
public class HalfInsertSort {
    public static void halfInsertSort(int[] arr, int length) {
        int i, j;
        int left, right, mid;
        int temp;
        for (i = 0; i < length; i++) {
            temp = arr[i];
            left = 0;
            right = i - 1;

            while (left <= right) {
                mid = (left + right) / 2;
                if (arr[mid] < temp) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
            mid = right + 1;

            for (j = i - 1; j >= mid; j--) {
                arr[j + 1] = arr[j];
            }
            arr[mid] = temp;
        }
    }
}

希尔排序

采用 3 ^ k + 1 作为间隔

package sort;

/**
 * @author bbyh
 * @date 2022/11/19 0019 18:23
 * @description
 */
public class ShellSort {
    private static final int NUM = 3;

    public static void shellSort(int[] arr, int length) {
        int gap = 1, i, j;
        int temp;
        while (gap < length / NUM) {
            gap = gap * 3 + 1;
        }
        for (; gap > 0; gap /= NUM) {
            for (i = gap; i < length; i++) {
                temp = arr[i];
                for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap) {
                    arr[j + gap] = arr[j];
                }
                arr[j + gap] = temp;
            }
        }
    }
}

交换式排序

冒泡排序

经典版本 与 优化版本：冒泡排序可以稍微改进一下，增加一个 flag 标志，标识在某一趟就已经排好序了，后面就不用再排序

package sort;

/**
 * @author bbyh
 * @date 2022/11/19 0019 18:29
 * @description
 */
public class BubbleSort {
    public static void bubbleSort(int[] arr, int length) {
        int i, j;
        int temp;
        for (i = 0; i < length; i++) {
            for (j = 0; j < length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    public static void bubbleSortImprove(int[] arr, int length) {
        int i, j;
        int flag;
        int temp;
        for (i = 0; i < length; i++) {
            flag = 0;
            for (j = 0; j < length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    flag = 1;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            if (flag == 0) {
                break;
            }
        }
    }
}

快速排序

哨兵模式的经典版本，采用递归实现； 采用辅助数组实现（相对哨兵模式会复杂一些，但并不难理解）

package sort;

/**
 * @author bbyh
 * @date 2022/11/19 0019 18:31
 * @description
 */
public class QuickSort {
    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pivot = partition(arr, low, high);
            quickSort(arr, low, pivot - 1);
            quickSort(arr, pivot + 1, high);
        }
    }

    private static int partition(int[] arr, int low, int high) {
        int temp = arr[low];
        int pivot = arr[low];
        while (low < high) {
            while (low < high && arr[high] >= pivot) {
                high--;
            }
            arr[low] = arr[high];
            while (low < high && arr[low] <= pivot) {
                low++;
            }
            arr[high] = arr[low];
        }
        arr[low] = temp;
        return low;
    }

    private static int partition(int[] arr, int[] temp, int low, int high) {
        int pivot = arr[low];
        int index = low + 1;

        while (low < high) {
            if (arr[index] > pivot) {
                temp[high--] = arr[index++];
            } else {
                temp[low++] = arr[index++];
            }
        }
        temp[low] = pivot;

        return low;
    }

    public static void quickSortExtraArray(int[] arr, int[] temp, int low, int high) {
        if (low < high) {
            int pivot = partition(arr, temp, low, high);

            int i;
            for (i = low; i < pivot; i++) {
                arr[i] = temp[i];
            }
            quickSortExtraArray(arr, temp, low, pivot - 1);

            for (i = pivot + 1; i <= high; i++) {
                arr[i] = temp[i];
            }
            quickSortExtraArray(arr, temp, pivot + 1, high);
        }
    }
}

选择式排序

选择排序

简单的选取然后交换

package sort;

/**
 * @author bbyh
 * @date 2022/11/19 0019 18:38
 * @description
 */
public class SelectSort {
    public static void selectSort(int[] arr, int length) {
        int i, j;
        int index;
        int temp;
        for (i = 0; i < length; i++) {
            index = i;
            for (j = i + 1; j < length; j++) {
                if (arr[j] < arr[index]) {
                    index = j;
                }
            }
            if (index != i) {
                temp = arr[i];
                arr[i] = arr[index];
                arr[index] = temp;
            }
        }
    }
}

堆排序

堆排序是利用大根堆或者小根堆实现的排序，在这个排序里面要解决两个问题，如何建立一个堆，以及如何对堆进行调整

需要注意的是，堆排序比较在意下标的变化，在 建堆 和 堆调整时，如果下标都采用 i < high 则没问题，但如果是采用 i <= high ，则会在建堆的时候出现小问题，而且只对小根堆出现问题，大根堆不会出现问题

下面是采用 大根堆 进行的升序排序

package sort;

/**
 * @author bbyh
 * @date 2022/11/19 0019 18:39
 * @description
 */
public class HeapSort {
    private static final int NUM = 2;

    private static void heapAdjust(int[] arr, int low, int high) {
        int temp = arr[low];
        int i;
        for (i = NUM * low; i < high; i *= NUM) {
            if (arr[i] < arr[i + 1]) {
                i++;
            }
            if (temp >= arr[i]) {
                break;
            }
            arr[low] = arr[i];
            low = i;
        }
        arr[low] = temp;
    }

    private static void createHeap(int[] arr, int length) {
        int i;
        for (i = length / NUM; i >= 0; i--) {
            heapAdjust(arr, i, length);
        }
    }

    public static void heapSort(int[] arr, int length) {
        createHeap(arr, length);

        int i;
        int temp;
        for (i = length - 1; i > 0; i--) {
            temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            heapAdjust(arr, 0, i - 1);
        }
    }
}

归并排序

这里采用经典的递归实现，左划分，右划分，然后合并

package sort;

/**
 * @author bbyh
 * @date 2022/11/19 0019 18:44
 * @description
 */
public class MergeSort {
    private static void merge(int[] arr, int[] temp, int start, int mid, int end) {
        int k = 0;
        int i = start;
        int j = mid + 1;

        while (i <= mid && j <= end) {
            if (arr[i] <= arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
            }
        }

        if (i == mid + 1) {
            while (j <= end) {
                temp[k++] = arr[j++];
            }
        }
        if (j == end + 1) {
            while (i <= mid) {
                temp[k++] = arr[i++];
            }
        }

        for (i = 0, j = start; i < k; i++, j++) {
            arr[j] = temp[i];
        }
    }

    public static void mergeSort(int[] arr, int[] temp, int start, int end) {
        if (start >= end) {
            return;
        }
        int mid = (start + end) / 2;
        mergeSort(arr, temp, start, mid);
        mergeSort(arr, temp, mid + 1, end);
        merge(arr, temp, start, mid, end);
    }
}

基数排序

不同于前面的比较式排序，这里采用桶思想，每次放入对应桶，从低位到高位，放入取出结束后，序列就有序了

package sort;

/**
 * @author bbyh
 * @date 2022/11/19 0019 18:46
 * @description
 */
public class RadixSort {
    private static final int NUM = 10;

    private static int getMax(int[] a, int length) {
        int i, max;
        max = a[0];
        for (i = 1; i < length; i++) {
            if (a[i] > max) {
                max = a[i];
            }
        }
        return max;
    }

    private static void countSort(int[] a, int length, int exp) {
        int[] temp = new int[length];
        int[] buckets = new int[NUM];

        int i;
        for (i = 0; i < length; i++) {
            buckets[(a[i] / exp) % NUM]++;
        }
        for (i = 1; i < NUM; i++) {
            buckets[i] += buckets[i - 1];
        }

        for (i = length - 1; i >= 0; i--) {
            temp[buckets[(a[i] / exp) % NUM] - 1] = a[i];
            buckets[(a[i] / exp) % NUM]--;
        }

        for (i = 0; i < length; i++) {
            a[i] = temp[i];
        }
    }

    public static void radixSort(int[] a, int length) {
        int exp;
        int max = getMax(a, length);
        for (exp = 1; max / exp > 0; exp *= NUM) {
            countSort(a, length, exp);
        }
    }
}
bingbingyihao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
排序算法—Java实现
vm04580
03-02 475
Java实现常见排序算法 日常操作中常见排序方法有：冒泡排序、快速排序、选择排序、插入排序、堆排序等 以下是各排序算法定义及代码实现： 1、冒泡排序（Bubble Sort）：是一种计算机科学领域的较简单的排序算法。 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序错误就把他们交换过来，直到没有相邻元素需要交换，也就是说该元素已经排序完成。该排序算法不稳定 /** * 冒泡排...
排序算法-Java实现
XIxixi丶曦的博客
04-02 85
快排 选取pivot 确定位置 重复确定 package main; import java.util.Scanner; public class QuickSort { public static void main(String[] args) { Scanner in = new Scanner(System.in); while (true){ int len = in.nextInt(); int[] nums = new int[len]; for (int i
十大经典排序算法——java语言
weixin_56781779的博客
11-11 5936
一、冒泡排序 二、选择排序 三、插入排序 四、希尔排序 五、归并排序 六、快速排序 七、堆排序 八、计数排序 九、桶排序 十、基数排序
排序算法-快速排序（Java实现）
博客
09-16 6432
快排是我们经常用到的经典排序算法之一，今天就来彻底的学习一下快排吧 文章目录算法思想代码实现-固定基准法代码实现-随机选取基准法代码实现-三分取中法快排优化-小序列优化快排优化-相同元素优化非递归实现快排最坏时间复杂度达到O(n log n) 算法思想       快速排序是指在待排序列中选取一个基准，然后把不比该基准大的放在基准的前面，...
排序算法-基数排序
qq_36944952的博客
12-30 3042
排序算法-基数排序 算法思想 完整代码实现： package com.sort; import java.util.LinkedList; import java.util.Queue; public class BaseSort { public static void main(String[] args) { int[] nums = {3,89,4,53,6,825,900,0,1000,53}; basesort(nums,nums.length);
详解Java常用排序算法-快速排序
08-26
快速排序算法详解 快速排序（Quick Sort）是一种分治思想的排序算法，它的...快速排序算法是一种高效、稳定的排序算法，广泛应用于各种编程语言和应用领域中。但是，它也存在一些缺点，需要在实际应用中注意这些缺点。
详解Java常用排序算法-堆排序
08-26
在上面的代码中，我们使用 Java 语言实现了堆排序算法。其中，Heap 类中包括两个函数：heapSort 和 heapify。heapSort 函数接受一个整数数组作为输入，并使用堆排序算法对该数组进行排序。heapify 函数用于对一个...
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
java代码-使用java解决java冒泡排序算法的源代码
04-04
java代码-使用java解决java冒泡排序算法的源代码 ——学习参考资料：仅用于个人学习使用！
最快的排序算法 javahash实现-Java-哈希算法-最快的实现，排序算法数据结构
04-07
Java哈希算法排序算法数据结构知识点总结 以下是关于Java哈希算法排序算法数据结构的知识点总结： 1. 哈希算法的速度问题：在讨论哈希算法的速度问题时，需要考虑到哈希函数的选择和实现方式。在大多数情况下，...
[C语言] 常用排序算法
qq_47500842的博客
06-16 267
常见排序算法
前端常用排序算法
qq_44242707的博客
06-14 374
【代码】前端常用排序算法。
排序1---插入排序
2301_80028974的博客
06-16 390
我们插入排序就是我们先假设前面的一段区间有序，然后从这个区间的后面一个位置开始，将该位置的值定位待插入的值，待插入的值与该区间的值进行比较，如果区间里面的值大于我们的待插入的值，就将这个值往后移一位，再继续比较，一直到我们比较完最后一个值，或者比较到一个比我们待插入值要小的值，这个时候我们就停止我们的比较。在将我们待插入的值插入比待插入值要小的值的后。首先我们要将我们待排序的值用一个变量存下来，因为我们往后面移动的这个行为会直接将后面的值给覆盖，这时我们待插入的值如果没有取出来的就会导致你找不到这个值了。
【C++提高编程-09】----C++ STL之常用排序算法
一伦明悦的博客
06-17 1099
STL（Standard Template Library）是C++标准库的一部分，提供了丰富的数据结构和算法，用于处理数据和实现常见的计算任务。STL中的算法分为几类，包括遍历算法、修改算法、排序算法、查找算法、数值算法等，每类算法都有其特定的应用场景和功能。
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 508
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
最新发布
m0_67496588的博客
06-20 536
JSON，Ajax
Java 中 什么是 lambda 表达式？有什么优点？
liangzai215的专栏
06-13 936
但是，Lambda 表达式绝对不是 Java 8 的银弹，它在消除代码冗余、支持并发这两方面表现优秀，但是在其他方面并未有太多贡献，所以我们在编程的时候，还是需要结合实际情况，灵活选择使用。Lambda表达式在Java 8中是非常强大的工具，但是需要注意的是，Lambda并并不适合所有情况，它主要适用于函数式编程，处理集合操作和Stream操作，在某些具体的业务逻辑操作中就不一定会产生预期的效果。代码块：是 Lambda 表达式需要执行的功能，可以是一行代码，也可以是复杂的多行代码。
基于springboot的青年公寓服务平台源码数据库
s123456sj的博客
06-16 1209
本青年公寓服务平台分为管理员还有用户两个权限，管理员可以管理用户的基本信息内容，可以管理房屋投诉信息以及房屋投诉的租赁信息，能够与用户进行相互交流等操作，用户可以查看房屋信息，可以查看房屋投诉以及查看管理员回复信息等操作。
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 417
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
希尔排序算法java语言
06-08
在Java中，希尔排序可以通过自定义方法实现，步骤如下： 1. **选择增量序列**：经典的增量序列有Hibbard序列、Shirley序列或直接使用等差序列如1, 4, 13, 37, ...直到增量为1。 2. **分组和插入排序**：对于当前...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值