常见排序(java实现)

已于 2022-04-14 08:43:34 修改
阅读量1.2k 收藏
点赞数 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));
    }
}
粉色的志明
关注
专栏目录
课程排序打印java实现
qq_19963919的博客
10-20 672
二维数组，文件流，内部类等技术知识实现打印课程表
课程排序java实现
guiguchunqiu的博客
12-04 480
class Solution { public int[] findOrder(int numCourses, int[][] prerequisites) { //这一题输出先修课程在后修课程之前的特点其实和拓扑排序的特点不谋而合 //第一步是根据prerequisites构建一张图 Map<Integer,List<Integer>> graph = new HashMap<>(); for(in
排序算法-java实现
qq_44300280的博客
12-17 623
Java实现十大排序算法 时间复杂度与空间复杂度
Java实现 207.课程表（拓扑排序）
Cypresszky的博客
05-06 487
你这个学期必须选修 numCourse 门课程，记为 0 到 numCourse-1 。 在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们：[0,1] 给定课程总量以及它们的先决条件，请你判断是否可能完成所有课程的学习？ 示例 1: 输入: 2, [[1,0]] 输出: true 解释: 总共有 2 门课程。学习课程 1 之前，你需要...
选择排序
OnHold的博客
10-12 127
直接上代码，注释写的应该是很详细了，不多解释 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实现.zip
07-30
本压缩包"常见的七大排序算法Java实现.zip"包含了七种经典的排序算法在Java语言中的实现。尽管文件列表中并未明确列出每种排序算法的名称，但根据常规，这七大排序算法可能包括冒泡排序、插入排序、选择排序、快速...
Java实现常见排序算法总结
05-02
【Java实现常见排序算法总结】 排序算法是计算机科学中至关重要的一部分，它涉及到数据处理和算法设计。本文将探讨两种常见的排序算法在Java中的实现：直接插入排序和希尔排序。 1. **直接插入排序（直接插入排序...
Java实现几种常见排序算法代码
09-05
【Java实现几种常见排序算法代码】的描述中提到了排序的重要性以及分类，下面将详细讲解这些排序算法。 1. **排序算法的意义与稳定度** - 排序是计算机科学中的基本操作，它使得数据组织有序，便于查找、分析和...
java实现常见排序算法
03-02
总结起来，Java实现的插入排序和交换排序为程序员提供了处理各种数据排序问题的工具。了解和掌握这些排序算法不仅有助于提升编程能力，也是解决实际问题的基础，尤其是在大数据处理和性能优化方面。在实际应用中，...
java常见排序算法合集讲解以及java实现.zip
11-29
Java中常见的排序算法 1.直接插入排序 2.希尔排序 3.选择排序 4.冒泡排序 5.归并排序 6.快速排序 7.堆排序 8.计数排序 9.桶排序 10....包含这十种算法的讲解以及动态图解（ppt）和java实现
经典排序算法---选择排序
辉的范你学不来的博客
07-16 134
选择排序是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，放到排序序列末尾。以此类推，直到所有的元素均排序完毕。 选择排序的交换操作介于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 1247
1，排序依据的规则：      一般来说，排序的目的是将一些数据依照某种特定的要求或原则排成递增或递减的顺序。而排序的过程中需要对键进行比较，主要依据以下三个规则：
第5章—千奇百怪的排序算法
weixin_42250357的博客
03-09 158
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
sorting算法
weixin_30246221的博客
04-05 134
排序算法： 冒泡排序： 冒泡排序算法的运作如下： 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个。 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 1 #include <iostr...
用java实现课程表_Java实现 LeetCode 207 课程表
weixin_42140716的博客
02-13 941
207. 课程表现在你总共有 n 门课需要选，记为 0 到 n-1。在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]给定课程总量以及它们的先决条件，判断是否可能完成所有课程的学习？示例 1:输入: 2, [[1,0]]输出: true解释: 总共有 2 门课程。学习课程 1 之前，你需要完成课程 0。所以这是可能的。示例...
代码随想录刷题学习日记
weixin_73939095的博客
10-23 1330
二叉树理论基础学习 二叉树的递归遍历学习 144.二叉树的前序遍历 94.二叉树的中序遍历 145.二叉树的后序遍历
连续数组和
最新发布
TangKenny的博客
10-30 405
给定一个含有N个正整数的数组,求出有多少个连续区间(包括单个正整数),它们的和大于等于x。第一行两个整数Nx0N
数据结构-栈
2403_82497315的博客
10-25 944
ADT Stack{数据对象：数据关系：约定 aₙ 端为栈顶， a₁端 为栈底基本操作：初始化、进栈、出栈、取栈顶元素等}ADT Stack// 栈底指针// 栈顶指针// 栈可用最大容量}SqStack/*StackNode：栈的结点类型*LinkStack：指向这个结点的指针类型*/// 数据域，存放元素// 指针域，指向下一元素，类型仍为struct链栈中的指针的方向是反过来的指针域中存放的是前驱元素链表的头指针就是栈顶不需要头结点基本不存在栈满的情况。
栈和队列（数据结构）
etamaos的博客
10-28 312
1.创建新队列（结点；
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

粉色的志明

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

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

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

打赏作者

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

抵扣说明：

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

余额充值