七大排序相关代码（没有堆排序）

最新推荐文章于 2022-05-19 16:36:35 发布
最新推荐文章于 2022-05-19 16:36:35 发布
阅读量122 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45896732/article/details/119185360
版权

堆排序 、 快速排序 、 希尔排序 、 直接选择排序 是不稳定的排序算法，而 冒泡排序 、 直接插入排序 、 折半插入排序 、 归并排序 是稳定的排序算法。
在这里插入图片描述

1.冒泡排序（O(n^2)）【括号内为时间复杂度】

package mian.Text;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
//80000万个数据检测速度：冒泡在该机器上用时：13秒
public class maopao {
    public static void main(String[] args) {
//        int [] arr = {1,2,3,4,5};
//        int [] arr = {1,3,2,4,5};
//        int [] arr = {3,9,-1,10,20};
        int [] arr = new int[80000];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random()*80000);
        }
        Date date = new Date();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String s = format.format(date);
        System.out.println(s);
        int temp = 0;
        boolean flag = false;
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j]>arr[j+1]){
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            if (!flag){
//                System.out.println("该数组已经排序完毕");
                break;
            }else {
                flag = false;
            }
//            System.out.println("第"+(i+1)+"次排序");
//            System.out.println(Arrays.toString(arr));

        }
        System.out.println("=====================================================");
        Date date2 = new Date();
        SimpleDateFormat format2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String ss = format2.format(date2);
        System.out.println(ss);
    }
}

2.选择排序 (O(n^2)）

package mian.Text;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
//80000万个数据检测速度：选择在该机器上用时：4秒
public class SelectSorting {
    public static void main(String[] args) {
        int []arr = {101,34,119,1,-1,90,123};
//        int [] arr = new int[80000];
//        for (int i = 0; i < arr.length; i++) {
//            arr[i] = (int) (Math.random()*80000);
//        }
//        Date date = new Date();
//        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//        String s = format.format(date);
//        System.out.println(s);
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            int min = arr[i];
            boolean flag = false;
            for (int j =  i+1; j < arr.length; j++) {
                if (min>arr[j]){
                    min = arr[j];
                    minIndex = j;
                }
            }
            if (minIndex!=i){
                flag = true;
                arr[minIndex] = arr[i];
                arr[i] = min;
            }


            if (flag){
                System.out.println("第"+(i+1)+"次");
                System.out.println(Arrays.toString(arr));
            }else {
                System.out.println("已是正确排序");
                break;
            }

        }

//        System.out.println("=====================================================");
//        Date date2 = new Date();
//        SimpleDateFormat format2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//        String ss = format2.format(date2);
//        System.out.println(ss);

//        System.out.println(Arrays.toString(arr));

    }

}

3.插入排序 (O(n^2)）

package mian.Text;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

//插入排序
//80000万个数据检测速度：插入在该机器上用时：2秒
public class InsertSort {
    public static void main(String[] args) {
//        int []arr = {6,5,4,3,2,1};
        int [] arr = new int[80000];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random()*80000);
        }
        Date date = new Date();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String s = format.format(date);
        System.out.println(s);
        int insertVal = 0 ;
        int index = 0;
        for ( int i= 1; i < arr.length; i++) {
            insertVal = arr[i];//要和前边对比的数
            index = i -1 ;//它的下标索引

            while (index >=0 && insertVal<arr[index]){
                arr[index+1] = arr[index];
                index--;
            }
            if(index + 1 == i){
                arr[index+1] = insertVal;
            }

//            System.out.println("第"+i+"次");
//            System.out.println(Arrays.toString(arr));
        }

        System.out.println("=====================================================");
        Date date2 = new Date();
        SimpleDateFormat format2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String ss = format2.format(date2);
        System.out.println(ss);
    }
}

4.希尔排序（O(nlogn)）

package mian.Text;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
80000万个数据检测速度：希尔排序在该机器上用时：不到1秒
public class shellSort {
    public static void main(String[] args) {
//        int []arr = {6,5,4,3,2,1};
        int count = 0;
        int [] arr = new int[80000];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random()*80000);
        }
        Date date = new Date();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String s = format.format(date);
        System.out.println(s);
        for (int gap = arr.length/2; gap > 0; gap/=2) {
            for ( int i= gap; i < arr.length; i++) {
                int index = i;
                int temp = arr[index];
                if (arr[index]<arr[index-gap]){
                    while (index - gap >=0 && temp<arr[index - gap]){
                        arr[index] = arr[index-gap];
                        index-=gap;
                    }
                }
                arr[index] = temp;
//                System.out.println("第"+(++count)+"次");
//                System.out.println(Arrays.toString(arr));
            }
        }


        System.out.println("=====================================================");
        Date date2 = new Date();
        SimpleDateFormat format2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String ss = format2.format(date2);
        System.out.println(ss);
    }
}

5.归并排序（O（nlogn））

package mian.Text;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
80000万个数据检测速度：归并排序在该机器上用时：不到1秒

public class MergeSort {
    public static void main(String[] args) {
//        int [] arr = {3,1,4,6,7,894,2,154,6,34};
        int [] arr = new int[80000];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random()*80000);
        }
        Date date = new Date();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
        String s = format.format(date);
        System.out.println(s);
        int []temp = new int[arr.length];
        mergeSort(arr,0,arr.length-1,temp);
        System.out.println("=====================================================");
        Date date2 = new Date();
        SimpleDateFormat format2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
        String ss = format2.format(date2);
        System.out.println(ss);
//        System.out.println(Arrays.toString(arr));
    }

    public static void mergeSort(int []arr,int left,int right,int[] temp){
        if (left<right){
            int mid = (left+right) / 2;
            mergeSort(arr,left,mid,temp);
            mergeSort(arr,mid+1,right,temp);
            merge(arr,left,mid,right,temp);
        }
    }
    public static void merge(int []arr,int left,int mid,int right,int[] temp){
        int i =left;
        int j = mid+1;
        int t = 0;
        while (i<=mid && j<=right){
            if (arr[i]<=arr[j]){
                temp[t] = arr[i];
                i++;
                t++;
            }else {
                temp[t] = arr[j];
                j++;
                t++;
            }
        }
        while (i <= mid){
            temp[t] = arr[i];
            i++;
            t++;
        }
        while (j <= right){
            temp[t] = arr[j];
            j++;
            t++;
        }
        t = 0;
        int templeft = left;
        while (templeft<=right){
            arr[templeft] = temp[t];
            templeft++;
            t++;
        }
    }
}

6.快排（O（nlogn））

package mian.Text;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
80000万个数据检测速度：快排在该机器上用时：不到1秒
public class QuickSort{
    public static void main(String[] args) {
//        int [] arr = {9,8,7,6,54,3,2,1};
        int count = 0;
        int [] arr = new int[8];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random()*80000);
        }
        Date date = new Date();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String s = format.format(date);
        System.out.println(s);
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
        System.out.println("=====================================================");
        Date date2 = new Date();
        SimpleDateFormat format2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String ss = format2.format(date2);
        System.out.println(ss);

    }

    public static void quickSort(int[] arr,int left,int right){
        if (left>=right){//只有一个数
            return;
        }
        int l = left;
        int r = right;
        int pivot = arr[left];
        while (l < r){
            while (l<r && arr[r]>=pivot){
                r--;
            }
            if (l<r){
                arr[l] = arr[r];
            }
            while (l<r && arr[l]<=pivot){
                l++;
            }
            if (l<r){
                arr[r] = arr[l];
            }
            if (l == r){
                arr[l] = pivot;
            }
        }
        quickSort(arr,left,l-1);
        quickSort(arr,l+1,right);
    }
}

7.基数排序（n*k）(k:桶子数)

package mian.Text;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.SimpleTimeZone;

//基数排序  80000个数据速度测试：<1秒
public class RadixSort {
    public static void main(String[] args) {
//        int []arr = {53,3,542,748,14,214};
        int []arr = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random()*80000);
        }
        Date date = new Date();
        SimpleDateFormat dateFormat =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = dateFormat.format(date);
        System.out.println(format);
        int [][]arrays = new int[10][arr.length];
        //array[?]就代表第几个桶里有多少数字，只是一个计数的数组
        int []array = new int[10];
        int temp = 0;
        int lmx = 0;
//        radixSort(arr, arrays, array, temp, lmx);
        Date date1 = new Date();
        SimpleDateFormat dateFormat1 =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format1 = dateFormat1.format(date1);
        System.out.println(format1);


    }

    private static void radixSort(int[] arr, int[][] arrays, int[] array, int temp, int lmx) {
        //找最大值
        for (int i = 0; i < arr.length; i++) {
            if (temp<arr[i]){
                temp = arr[i];
            }
        }
        //执行几次
        int count = 0;
        while (temp>0){
            temp = temp/10;
            count++;
        }
        for (int i = 0,n = 1; i < count; i++, n*=10) {


            //放
            for (int j = 0; j < arr.length; j++) {
                int a = arr[j] / n %10;
                arrays[a][array[a]] = arr[j];
                array[a]++;
            }
            //取
            for (int q = 0; q < array.length; q++) {
                if (array[q]!= 0){
                    for (int k = 0; k < array[q]; k++) {
                        arr[lmx++] = arrays[q][k];
                    }
                }
                //把桶清空
                array[q] = 0;
            }
            lmx = 0;
            System.out.println(Arrays.toString(arr));
        }
    }
}
学不明白后端的小菜鸡~
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
常见的七大排序算法Java实现.zip
07-30
尽管文件列表中并未明确列出每种排序算法的名称，但根据常规，这七大排序算法可能包括冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序和计数排序。 1. **冒泡排序**：冒泡排序是一种简单的排序算法，...
Java中七大基于比较的排序算法
01-21
目录插入排序直接插入排序基本原理代码实现性能分析折半插入排序代码实现希尔排序基本原理代码实现性能分析选择排序单向选择排序基本原理代码实现性能分析双向选择排序代码实现堆排序基本原理代码实现性能分析冒泡...
七大经典排序算法(动图演示+代码展示)
weixin_43224539的博客
04-21 3369
常见排序算法可以分为两大类：非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。线性时间非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。 算法复杂度 1. 冒泡排序(BubbleSort) 冒泡排序是一种简单的排序算法，是...
七大常见排序算法总结
热门推荐
lutianfei的专栏
07-19 2万+
插入类排序 直接插入排序 希尔排序 选择类排序 简单选择排序 堆排序 交换类排序 冒泡排序 快速排序 归并类排序 归并排序
万字手撕七大排序（代码+动图演示）
m0_57304511的博客
04-29 1万+
万字手撕七大排序（代码+动图演示）
七大排序——堆排序
m0_68989458的博客
05-19 401
七大排序——堆排序
七大排序之堆排序
makabaka_sss_的博客
03-04 49
堆排序是比较稳定的排序方式,且时间复杂度为 nlogn; 1.先将数组元素下沉,形成最大堆,此时堆顶元素就是最大的元素,它应当在数组最后 2.将堆顶元素与最后一个元素交换 3.保持最后一个元素不动,下沉堆顶元素 具体代码如下: public class Test { public static void heapSort(int[] arr){ // 每个元素下沉,得到最大堆 for (int i = 0; i < arr.length; i++)
七大排序算法
03-14
包含（归并排序、堆排序、希尔排序、快速排序、冒泡排序、直接插入/选择排序）七种排序算法的C++代码实现
计算机七大排序
10-16
七大排序算法包括冒泡排序、直接插入排序、直接选择排序、希尔排序、归并排序、快速排序和堆排序。 冒泡排序是一种简单的排序算法，其思路是每次将最大或最小的元素放到数组的最后。该算法的时间复杂度为O(n^2)，...
Java语言：七大排序算法精彩讲解+详细代码+思路分析+最佳优化！
最新发布
02-05
接插入排序时，退出循环。下面是希尔排序的代码实现： ```java public void shellSort(int[] array) { ...在理解和掌握了这些排序算法后，还可以考虑其他优化策略，如归并排序、堆排序等，以进一步提高排序效率。
leecode每日两题~持续更新
qq_45896732的博客
11-10 4349
1、删除单链表中某个特定节点 如：1 -> 2 -> 3 ->4 删掉2 变成 1 -> 3 ->4 思路：首先方法中传参过来的那个节点就是要删的节点node，找到要删节点的下一个节点node.next，把node.next的值给了node（覆盖），也就变成了 1 -> 3 -> 3 ->4，然后将node的指针指向node的下一个的下一个节点，也就是node.next.next,这样就会使得原来的3没有指针指向，被垃圾回收，所以最后变成1 ->
稀疏数组及io写入和读取
qq_45896732的博客
07-12 177
package com.main.dataStructures; import java.io.*; import java.util.ArrayList; import java.util.Arrays; import java.util.List; //1.创建一个二维数组 //2.将二维数组转换为稀疏数组 //3.将稀疏数组保存到磁盘中 //4.读取磁盘中的文件，转换为稀疏数组 //5.将稀疏数组转换为二维数组 public class SparseArray { public stati
普通队列和环形队列
qq_45896732的博客
07-13 144
普通 思路分析： 1)将尾指针往后移: rear+1, 当front== rear [ 空] 2)若尾指针rear小于队列的最大下标maxSize-1,则将数据存入rear所指的数 组元素中，否则无法存入数据。rear == maxSize- 1[队列满] 代码实现： package com.main.dataStructures; public class ArrayQueueDemo{ public static void main(String[] args) { ArrayQ
java中你没见过的使=实用方法，减少代码量，你值得拥有
qq_45896732的博客
07-16 98
package com.main.Test; import com.sun.xml.internal.ws.util.StringUtils; import org.apache.commons.io.FileUtils; import java.io.File; import java.io.IOException; import java.nio.charset.Charset; import java.util.*; import java.util.stream.Collectors; pu
单链表简单的增删改查
qq_45896732的博客
07-13 94
1)链表是以节点的方式来存储，是链式存储 2)每个节点包含 data域，next域:指向下一个节点. 3)如图: 发现链表的各个节点不一定是连续存储. 4)链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 思路分析： 添加(创建) 1.先创建- -个head头节点，作用就是表示单链表的头 2.后面我们每添加一-个节点，就直接加入到链表的最后遍历: 代码实现：（按添加顺序排序） package com.main.dataStructures; public class SingleLinked
单链表大厂面试题
qq_45896732的博客
07-15 82
求单链表的有效个数(不算头节点) //求单链表的有效个数(不算头节点) public static int getLength(HeroNode head){ if (head.next == null){ return 0; } HeroNode temp = head.next; int length = 0; while (temp != null){ length+
单向环形链表（Josepfu）
qq_45896732的博客
07-16 81
➢Josephu 问题 Josephu 问题为:设编号为1，2, … n的n个人围坐一-圈，约定编号为k (1<=k<=n) 的人 从1开始报数，数到m的那个人出列，它的下一位又从1开始报数，数到m的那个人又出 列，依次类推，直到所有人出列为止，由此产生-一个出队编号的序列。 构建-个单向的环形链表思路 1.先创建第-一个节点,让first指向该节点，并形成环形 2.后面当我们每创建一个新的节点，就把该节点，加入到已有的环形链表中即可 遍历环形链表 1.先让一个辅助指针(变量)curBoy,指
双向链表CRUD
qq_45896732的博客
07-15 74
分析双向链表的遍历，添加，修改，删除的操作思路===》代码实现 1)遍历方和单链表-样，只是可以向前，也可以向后查找 2)添加(默认添加到双向链表的最后) (1)先找到双向链表的最后这个节点 (2) temp.next =newHeroNode (3) newHeroNode.pre =temp; 3)修改思路和原来的单向链表一样. 4)删除 (1)因为是双向链表，因此，我们可以实现自我删除某个节点 (2)直接找到要删除的这个节点，比如temp (3) temp.pre.next = temp.next (
"Java语言七大排序算法精彩讲解：代码、思路、优化！
本章内容主要围绕Java语言中的七大排序算法展开精彩讲解，详细介绍了每种排序算法的具体代码实现、思路分析以及最佳优化方法。在学校中，人们常常会遇到各种排序场景，如身高从矮到高排队、考勤表按照学号从低到高...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值