常见排序(java实现)

已于 2022-04-14 08:43:34 修改
阅读量1.1k 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
于 2022-04-03 12:26:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenbaifan/article/details/123934848
版权

排序

插入排序

图解

在这里插入图片描述

代码实现

public class TestDemo {

    public static void main(String[] args) {
        int[] array = {5,4,3,2,1};  //定义数组
        insertSort(array);
        System.out.println(Arrays.toString(array));
    }

    public static void insertSort(int[] array){ 
        for (int i = 1; i < array.length; i++) {
            int j = i - 1; //
            int tmp = array[i]; // 记录i下标的值
            for(;j >= 0;j--){  //从j位置往后遍历,
                if(array[j] > tmp){
                    array[j + 1] = array[j]; //大的放到前面
                }else{
                    break;
                }
            }
            array[j + 1] = tmp;//最后最小的给放到前面,(j一直在减减)
        }
    }
}

在这里插入图片描述

希尔排序

图解

在这里插入图片描述

代码实现

public class ShellSort {

    public static void main(String[] args) {
        int[] array = {12,5,9,34,6,8,33,56,89,0,7,4,22,55,77};
        shellSort(array);
        System.out.println(Arrays.toString(array));
    }

    public static void shell(int[] array,int gap){
        for (int i = gap; i < array.length; i++) {  //先按分组排
            int j = i - gap;
            int tmp = array[i]; //记录i下标值
            for(;j >= 0;j -= gap){
                if(array[j] > tmp){
                    array[j + gap] = array[j]; //交换
                }else{
                    break;
                }
            }
            array[j + gap] = tmp; //还回去
        }
    }


    public static void shellSort(int[] array){
        int gap = array.length; //分组
        while(gap > 1){ //这里是循环条件
            shell(array,gap);
            gap /= 2;
        }
        shell(array,1); //最后就是分成一组最后的排序
    }
}

在这里插入图片描述

选择排序

图解

在这里插入图片描述

代码实现

public class SelectSort {

    public static void main(String[] args) {
        int[] array = {1,4,12,6,7};
        selectSort(array);
        System.out.println(Arrays.toString(array));
    }

    public static void selectSort(int[] array){
        for (int i = 0; i < array.length; i++) {
            int min = i;  //记录最小的值下标
            for (int j = i+1; j < array.length; j++) {
                if(array[j] < array[min]){  //比较当前下标值得大小
                    min = j;
                }
            }
            swap(array,i,min);   //交换最小值在前面去
        }
    }

    private static void swap(int[] array, int a, int b) {   //交换函数
        int tmp = array[a];
       array[a] = array[b];
       array[b] = tmp;
    }
}

在这里插入图片描述

冒泡排序

图解

在这里插入图片描述

代码实现

public class MaoPaoSort {
    public static void main(String[] args) {
        int[] array = {6,12,10,3,5};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }

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


    public static void bubbleSort(int[] array) {
        for (int i = 0; i < array.length-1; i++) {
            boolean flg = false;  //优化,
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j] > array[j+1]) {
                    swap(array,j+1,j);
                    flg = true; //说明这里进入了交换语句,把flg改成true
                }
            }
            if(flg == false) {  //说明这里并没有进入交换语句,说明这个数组已经有序了,直接返回
                break;
            }
        }
    }

}

堆排

图解

在这里插入图片描述详情见代码

代码实现

public class HeapSort {

    public static void main(String[] args) {
        int[] array = {27,15,19,18,28,34,65,49,25,37};
        heapSort(array);
        System.out.println(Arrays.toString(array));
    }

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

    public static void heapSort(int[] array) {
        //1、建堆  O(N)
        createHeap(array);
        int end = array.length-1;
        //2、交换然后调整 O(N * log N)
        while (end > 0) {
            swap(array,0,end);
            shiftDown(array,0,end);
            end--;
        }
    }

    public static void createHeap(int[] array) {  //建堆
        for (int parent = (array.length-1-1)/2; parent >= 0 ; parent--) {
            shiftDown(array,parent,array.length);
        }
    }

    public static void shiftDown(int[] array,int parent,int len) {  //大根堆
        int child = 2*parent+1;//左孩子下标
        while (child < len) {
            if(child+1 < len && array[child] < array[child+1]) {
                child++;
            }
            //child下标 就是左右孩子最大值的下标
            if(array[child] > array[parent]) {
                swap(array,child,parent);
                parent = child;
                child = 2*parent+1;
            }else {
                break;
            }
        }
    }

}

在这里插入图片描述

快排

图解

在这里插入图片描述

代码实现(挖坑法)

public class QuickSort {

    public static void main(String[] args) {
int[] array = {6,1,2,7,9,3,4,5,10,8};
quickSort(array);
        System.out.println(Arrays.toString(array));
    }

    public static void quickSort(int[] array){  //快排
        quick(array,0,array.length - 1);
    }

    public static void quick(int[] array,int left,int right){ //递归

        if(left >= right){  //递归结束条件
            return;
        }
        int pivot = partition(array,left,right);  //基准值
        quick(array,left,pivot - 1);  //递归左边的
        quick(array,pivot + 1,right);  //递归右边的
    }

    public static int partition(int[] array,int start,int end){  //基准值
        int tmp = array[start];  //让开始下标放到tmp中
        while(start < end){  //循环条件
            if(start < end && array[end] >= tmp){   //start < end是大前提,所以又要写一遍
                end--;
            }
            array[start] = array[end];  //放到前面
            if(start < end && array[start] <= tmp){
                start++;
            }
            array[end] = array[start]; //放到后面
        }
        array[start] = tmp; //放回tmp值
        return start;  //返回下标(基准值)
    }
}

在这里插入图片描述
优化一下这个代码,我们这样一直找第一个并不确定这个数是大是小,我们用三数取中法找到中间值与start交换后再快排.详情见代码

快排优化(三数取中法)

public class QuickSort {

    public static void main(String[] args) {
int[] array = {6,1,2,7,9,3,4,5,10,8};
quickSort(array);
        System.out.println(Arrays.toString(array));
    }

    public static void swap(int[] array,int a,int b){
        int tmp = array[a];
        array[a] = array[b];
        array[b] = tmp;
    }

    public static void quickSort(int[] array){  //快排
        quick(array,0,array.length - 1);
    }

    public static void quick(int[] array,int left,int right){ //递归

        if(left >= right){  //递归结束条件
            return;
        }

        //1、找基准之前，我们找到中间大小的值-使用三数取中法
        int midValIndex = findMidValIndex(array,left,right);  //这样有可能大大提升了代码的效率
        swap(array,midValIndex,left);

        int pivot = partition(array,left,right);  //基准值
        quick(array,left,pivot - 1);  //递归左边的
        quick(array,pivot + 1,right);  //递归右边的
    }

    private static int findMidValIndex(int[] array,int start,int end) {  //找到这三个数的中间值
        int mid = start + ((end-start) >>> 1);  //(start + end) / 2;
        if(array[start] < array[end]) {
            if(array[mid] < array[start]) {
                return start;
            }else if(array[mid] > array[end]) {
                return end;
            }else {
                return mid;
            }
        }else {
            if(array[mid] > array[start]) {
                return start;
            }else if(array[mid] < array[end]) {
                return end;
            }else {
                return mid;
            }
        }
    }


    public static int partition(int[] array,int start,int end){  //基准值
        int tmp = array[start];  //让开始下标放到tmp中
        while(start < end){  //循环条件
            if(start < end && array[end] >= tmp){   //start < end是大前提,所以又要写一遍
                end--;
            }
            array[start] = array[end];  //放到前面
            if(start < end && array[start] <= tmp){
                start++;
            }
            array[end] = array[start]; //放到后面
        }
        array[start] = tmp; //放回tmp值
        return start;  //返回下标(基准值)
    }
}

非递归实现

在这里插入图片描述

public class Demo1 {

    public static void main(String[] args) {
        int[] array = {6,1,2,7,9,3,4,5,10,8};
        quickSort(array);
        System.out.println(Arrays.toString(array));
    }

    public static void quickSort(int[] array) {
        Stack<Integer> stack = new Stack<>();
        int left = 0;
        int right = array.length - 1;
        int pivot = partiton(array, left, right); //基准值
        if (pivot > left + 1) {   //左边是不是只有一个了
            stack.push(left);
            stack.push(pivot - 1);
        }
        if (pivot < right - 1) {
            stack.push(pivot + 1);
            stack.push(right);
        }
        while (!stack.isEmpty()) {
            right = stack.pop();  //新的右下标
            left = stack.pop();  //新的左下标
            pivot = partiton(array, left, right); //新的基准值
            if (pivot > left + 1) {
                stack.push(left);
                stack.push(pivot - 1);
            }
            if (pivot < right - 1) {
                stack.push(pivot + 1);
                stack.push(right);
            }
        }
    }

    public static int partiton(int[] array, int start, int end) {
        int tmp = array[start];
        while (start < end) {
            while (start < end && array[end] >= tmp) {
                end--;
            }
            array[start] = array[end];
            while (start < end && array[start] <= tmp) {
                start++;
            }
            array[end] = array[start];
        }
        array[start] = tmp;
        return start;
    }

}

在这里插入图片描述

归并排序

在这里插入图片描述

代码实现

import java.util.Arrays;

public class Demo4 {
    /*
     * 时间复杂度：N * log2 N
     * 空间复杂丢：O(N)
     * 稳定性：稳定
     * */
    public static int[] mergeSort(int[] array){
        if(array == null){
            return array;
        }
        mergeSortFunc(array,0,array.length-1);
        return array;
    }
    private static void mergeSortFunc(int[] array,int low,int high){
        if(low >= high){
            return;
        }
//       int mid = (high + low) >>> 1
        int mid = low + ((high - low) >>> 1);
        mergeSortFunc(array,low,mid);// 左边
        mergeSortFunc(array,mid+1,high);// 右边
        merge(array,low,mid,high);
    }

    private static void merge(int[] array,int low,int mid,int high){
        int[] arr = new int[high - low +1];
        int start1 = low;
        int end1 = mid;
        int start2 = mid+1;
        int end2 = high;
        int i = 0;
        while (start1 <= end1 && start2 <= end2){
            if(array[start1] > array[start2]){
                arr[i++] = array[start2++];
            }else{
                arr[i++] = array[start1++];
            }
        }
        while(start1 <= end1){
            arr[i++] = array[start1++];
        }
        while(start2 <= end2){
            arr[i++] = array[start2++];
        }
        for (int j = 0; j < arr.length; j++) {
            array[low++] = arr[j];
        }
    }

    public static void main(String[] args) {
        int[] array = {1,6,7,10,2,3,4,9};
        mergeSort(array);
        System.out.println(Arrays.toString(array));
    }
}

在这里插入图片描述

非递归

import java.util.Arrays;

public class MergeSortNonRecursion {
    public static void mergeSort(int[] array){
        //归并排序非递归实现
        int groupNum = 1;// 每组的数据个数
        while(groupNum < array.length){
            // 无论数组含有几个元素， 数组每次都需要从下标 0位置，开始遍历。
            for(int i = 0;i<array.length;i+= groupNum * 2){
                int low = i;
                int mid = low + groupNum -1;

                // 防止越界【每组的元素个数，超过了数组的长度】
                if(mid >= array.length){
                    mid = array.length-1;
                }
                int high = mid + groupNum;

                // 防止越界【超过了数组的长度】
                if(high >= array.length){
                    high = array.length-1;
                }
                merge(array,low,mid,high);
            }
            groupNum *= 2;//每组的元素个数扩大到原先的两倍。
        }
    }
    public static void merge(int[] array,int low,int mid,int high){
    // high 与 mid 相遇，说明 此时数组分组只有一组，也就说没有另一组的数组与其合并
    // 即数组已经有序了，程序不用再往下走。
         if(high == mid){
            return;
        }
        int[] arr = new int[high -low + 1];
        int start1 = low;
        int end1 = mid;
        int start2 = mid+1;
        int end2 = high;
        int i = 0;
        while(start1 <= end1 && start2 <= end2){
            if(array[start1]>array[start2]){
                arr[i++] = array[start2++];
            }else{
                arr[i++] = array[start1++];
            }
        }
        while (start1 <= end1){
            arr[i++] = array[start1++];
        }
        while(start2 <= end2){
            arr[i++] = array[start2++];
        }
        for (int j = 0; j < arr.length; j++) {
            array[low++] = arr[j];
        }
    }

    public static void main(String[] args) {
        int[] array = {12,5,8,7,3,4,1,10};
        mergeSort(array);
        System.out.println(Arrays.toString(array));
    }
}
粉色的志明
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
课程排序打印java实现
qq_19963919的博客
10-20 628
二维数组，文件流，内部类等技术知识实现打印课程表
课程排序java实现
guiguchunqiu的博客
12-04 452
class Solution { public int[] findOrder(int numCourses, int[][] prerequisites) { //这一题输出先修课程在后修课程之前的特点其实和拓扑排序的特点不谋而合 //第一步是根据prerequisites构建一张图 Map<Integer,List<Integer>> graph = new HashMap<>(); for(in
排序算法-java实现
qq_44300280的博客
12-17 573
Java实现十大排序算法 时间复杂度与空间复杂度
Java实现 207.课程表（拓扑排序）
Cypresszky的博客
05-06 454
你这个学期必须选修 numCourse 门课程，记为 0 到 numCourse-1 。 在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们：[0,1] 给定课程总量以及它们的先决条件，请你判断是否可能完成所有课程的学习？ 示例 1: 输入: 2, [[1,0]] 输出: true 解释: 总共有 2 门课程。学习课程 1 之前，你需要...
选择排序
OnHold的博客
10-12 102
直接上代码，注释写的应该是很详细了，不多解释 public class SelectSort { public static void main(String[] args) { int[] arr = {0,3,6,2,4,9,8,7,1}; selectSort(arr); for(int a : arr){ System.out.print(a+" "); } }...
十大经典排序算法（Java实现）
热门推荐
qq_43794633的博客
12-04 1万+
为了加深对这十种算法的理解，固写此文。首先可用如下表来简单概括这十种算法： 目录1、冒泡排序2、选择排序3、插入排序4、希尔排序5、归并排序6、快速排序7、堆排序8、计数排序9、桶排序10、基数排序 十大经典排序算法 平均时间复杂度 最好时间复杂度 最坏时间复杂度 空间复杂度 排序方式 稳定性 冒泡排序 O\OmicronO(n2) O\OmicronO(n) O\OmicronO(n2) O\OmicronO(1) In-place 稳定 选择排序 O\OmicronO(n2) O\O
Java实现常见排序算法总结
05-02
主要是针对常见的排序算法进行分析实现
java实现常见排序算法
03-02
java实现插入排序，交换排序。插入排序包括直接插入排序，折半插入排序和希尔排序。交换排序包括冒泡排序。
java常见排序算法合集讲解以及java实现.zip
11-29
Java中常见的排序算法 1.直接插入排序 2.希尔排序 3.选择排序 4.冒泡排序 5.归并排序 6.快速排序 7.堆排序 8.计数排序 9.桶排序 10....包含这十种算法的讲解以及动态图解（ppt）和java实现
Java实现几种常见排序算法代码
09-05
排序(Sorting) 是计算机程序设计中的一种重要操作，它的功能是将一个数据元素（或记录）的任意序列，重新排列成一个关键字有序的序列
java实现数据结构常见排序算法及详解
11-08
详细讲述了8中常见算法的原理及思想，并用JAVA进行了实现，代码中有详细的注释，解释了算法的实现逻辑和一些小技巧。
经典排序算法---选择排序
辉的范你学不来的博客
07-16 98
选择排序是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，放到排序序列末尾。以此类推，直到所有的元素均排序完毕。 选择排序的交换操作介于0和（n-1）次之间；选择排序的比较操作为n(n-1)/2次之间；选择排序的赋值操作介于0和3（n-1）次之间；其平均复杂度为O(n2)。 代码如下： public class SelectSort { public static void main(String[] args
排序 Sorting（java实现）
JemmaWang的博客
10-26 1204
1，排序依据的规则：      一般来说，排序的目的是将一些数据依照某种特定的要求或原则排成递增或递减的顺序。而排序的过程中需要对键进行比较，主要依据以下三个规则：
第5章—千奇百怪的排序算法
weixin_42250357的博客
03-09 137
5.1 常用的排序算法 可以用Array.sort()直接排序，也可写排序算法 1、冒泡排序 从左向右去遍历，依次去比较相邻的值，发现逆序则交换，使较大值依次往后移动，第一次找到最大值，第二次找到第二大值。。。 public static void bubbleSort(int[] arr) { int temp = 0; // 临时变量 boolean flag = false; // 标识变量， 表示是否进行过交换 for (int i = 0; i < arr.length - 1; i
【刷题（13）】二分查找
m0_51579041的博客
05-29 1043
【刷题（13）】二分查找
算法导论 总结索引 | 第三部分 第十四章：数据结构的扩张
AsherGu的博客
06-01 485
动态顺序统计；如何扩张数据结构；区间树
字符串逆序数据结构
最新发布
2301_77487444的博客
06-01 251
此外，还可以使用链表（LinkedList）数据结构来实现字符串的逆序。可以将字符串中的每个字符存储在链表节点中，然后遍历链表从后向前读取节点，即可得到字符串的逆序。可以将字符串中的每个字符存储在数组中，然后遍历数组从后向前读取字符，即可得到字符串的逆序。在数据结构中，字符串可以被视为一种特殊的数据类型，可以看作由字符组成的有序序列。需要注意的是，逆序只是改变了字符的顺序，并没有改变字符之间的关系。可以将字符串中的每个字符依次入栈，然后依次出栈，出栈的顺序即为字符串的逆序。
C数据结构：二叉树
2301_80655639的博客
05-27 989
这里二叉树是使用了链式存储data负责存储数据，left指针负责存储左孩子节点，right负责存储右孩子节点。
8_Android app作业-源码.zip
06-01
提供的源码资源涵盖了安卓应用、小程序、Python应用和Java应用等多个领域，每个领域都包含了丰富的实例和项目。这些源码都是基于各自平台的最新技术和标准编写，确保了在对应环境下能够无缝运行。同时，源码中配备了详细的注释和文档，帮助用户快速理解代码结构和实现逻辑。 适用人群： 这些源码资源特别适合大学生群体。无论你是计算机相关专业的学生，还是对其他领域编程感兴趣的学生，这些资源都能为你提供宝贵的学习和实践机会。通过学习和运行这些源码，你可以掌握各平台开发的基础知识，提升编程能力和项目实战经验。 使用场景及目标： 在学习阶段，你可以利用这些源码资源进行课程实践、课外项目或毕业设计。通过分析和运行源码，你将深入了解各平台开发的技术细节和最佳实践，逐步培养起自己的项目开发和问题解决能力。此外，在求职或创业过程中，具备跨平台开发能力的大学生将更具竞争力。 其他说明： 为了确保源码资源的可运行性和易用性，特别注意了以下几点：首先，每份源码都提供了详细的运行环境和依赖说明，确保用户能够轻松搭建起开发环境；其次，源码中的注释和文档都非常完善，方便用户快速上手和理解代码；最后，我会定期更新这些源码资源，以适应各平台技术的最新发展和市场需求。
常见排序算法java实现
07-12
常见的排序算法有许多种，以下是一些常见的排序算法的Java实现示例： 1. 冒泡排序（Bubble Sort）： ```java public void bubbleSort(int[] arr) { int n = arr.length; for (int i = 0; i ; i++) { for (int j ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

粉色的志明

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值