【数据结构】用java实现不同的七种排序算法和性能比较

最新推荐文章于 2023-05-11 18:00:48 发布
最新推荐文章于 2023-05-11 18:00:48 发布
阅读量434 收藏
点赞数
分类专栏： 算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41358574/article/details/118662207
版权

文章目录

1.直接插入排序

public class DifferentSort {
    public static void main(String[] args) {
        Insert insert = new Insert();
        insert.sort();
    }
}
class Insert {
    int total;
    int[] data = new int[10];

    Insert() {
        Random random = new Random();
        for (int i = 0; i < 10; i++)
            data[i] = random.nextInt() %100;

    }

    void sort() {
        total = 10;
        int j;
        int temp;
        for (int i = 1; i < total; i++) {
            temp = this.data[i];
            j = i - 1;
          //  System.out.println(j);

                while (data[j] > temp && j >=0) {
                    data[j+1] = data[j];
                    j--;
                 if(j < 0) break;

                }
            data[j+1] = temp;

        }
        for (int i = 1; i < total; i++)
            System.out.println(data[i]);
    }
}

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

2.希尔排序

插入排序的改进版，插入排序当序列为正序或基本有序时时间复杂度为o(n),希尔排序的基本思想：待排序列划分为若干组，每组内进行直接插入排序，然后再对整个序列直接排序
步长的变化：1<dl<=n/2
初始步长可以直接决定希尔排序的性能

class  Shell{
    int total;
    int[] data = new int[10];

    Shell() {
        total = 10;
        Random random = new Random();
        for (int i = 0; i < 10; i++)
            data[i] = random.nextInt(100) %60;
        for (int i = 0; i < 10; i++)
            System.out.print(data[i]+",");

    }
    public void shell_sort(){
        int temp;
        int j;
        int dl = this.total/2;//初始步长
        while(dl >=1){
            for(int i = 1+dl;i < total;i++)
            {
                temp = data[i];
                j = i-dl;
                while (j>=0 && data[j] > temp)
                {
                    data[j+dl] =data[j];
                    j = j-dl;
                    if(j < 0) break;
                }
                data[j+dl] = temp;
            }
            dl  = dl/2;
        }
        System.out.println("希尔排序后");
        for (int i = 1; i < total; i++)
            System.out.print(data[i]+",");
    }

}

结果：
18,29,29,48,12,17,15,0,0,33,希尔排序后
0,0,12,15,17,29,29,33,48,
改数字为十万后：
在这里插入图片描述

3.冒泡排序

每一次都浮上来最小的元素，是稳定的排序算法
以下用exchange作为标记，如果为false表示已经排序完成，可以不再执行下一次循环

class pop{
    int total = 100000;

    int[] data = new int[total];
   pop() {
       Random random = new Random();
       for (int i = 0; i < total; i++)
           data[i] = random.nextInt() % 60000;
       for (int i = 0; i < total; i++)
           System.out.print(data[i] + ",");
   }

    public void pop_sort() {
       boolean exchange = false;
for(int i = 1;i < total;i++)
{
    for(int j = total-1;j >= i;j--)
    {
        if(data[j] < data[j-1])
        {
            exchange = true;
            int temp = data[j];
            data[j]= data[j-1];
            data[j-1] = temp;
        }

    }
    if(exchange == false) break;
}
        System.out.println("冒泡排序后");
        for (int i = 1; i < total; i++)
            System.out.print(data[i]+",");
    }
}

结果：
在这里插入图片描述
明显看出来冒泡排序实在太慢，与希尔排序相比差了有五十倍
在这里插入图片描述

4.快速排序

首先选一个元素作为中间元素，然后对两边进行同样的操作,递归进行

class Quick{
    Integer partion;
  int total = 10000;
    //Integer n = 100;解析为 Integer num = Integer.valueOf(100);
    //valueOf(参数)方法其实调用的是 new Integer(100);
  int[]data= new int[total];
 
int n = 0;
    Quick(){

        Random random = new Random();
        for (int i = 0; i < total; i++)
            data[i] = random.nextInt(1000) %1000;
        for (int i = 0; i < total; i++)
            System.out.print(data[i]+",");
    }
    public Integer getN(){
        return this.n;
    }
    public Integer get(){
        return this.total;
    }
    public int part(int begin,int end){
      int temp;
        temp = data[begin];
      int i = begin,j = end;
   while (i != j)
        {
      while(i <j &&data[j] > temp) {

         j--;
         }
      if(i < j){
          data[i] = data[j];//data[j]填补到空位中,交换
          i++;
      }
         while (data[i] < temp && i < j)
         {
             i++;
         }
         if(i < j){
             data[j] = data[i];j--;//填补到后面的空位中
         }
        }
   data[i] = temp;//最终temp的位置

      
        return i;
    }
    public void Quick_sort(int n,int total){

       // Integer i = new Integer(10);

        if(n < total){
          int partnum =  part(n,total);
            Quick_sort(n,partnum-1);
            Quick_sort(partnum+1,total);
        }
        else {

            return;
        }
    }
    public void display(){
        System.out.println("快速排序后");
        for (int i = 1; i < total; i++)
            System.out.print(data[i]+",");
    }
}

    public static void main(String[] args) {
        long now = System.currentTimeMillis();
Quick quick = new Quick();

quick.Quick_sort(quick.getN(),quick.get()-1);
quick.display();
long now2 = System.currentTimeMillis();
        System.out.println();
        System.out.println(now2-now+"ms");
    }

排十万个数字：
在这里插入图片描述
目前的话看得出快速排序比希尔排序更快，性能是最好的。
另外在这里尝试了用Integer,发现会导致程序死循环，原因还未查明，应该跟它的数字范围有关

在这里插入图片描述

5.选择排序

关键思想：每一次都把关键字最小或最大的元素放在最终位置上，选择排序包括堆排序和直接选择排序
直接选择排序通过待排子表中完整地比较一遍以确定最大或最小元素，并放在子表的最前面/最后面

class choose{
    int total = 100000;

    int[] data = new int[total];
    choose(){
        Random random = new Random();
        for (int i = 0; i < total; i++)
            data[i] = random.nextInt(10000) % 10000;
        for (int i = 0; i < total; i++)
            System.out.print(data[i] + ",");
    }
    public void choose_sort(){
        int min = Integer.MAX_VALUE;
        for(int i = 0;i < total-1;i++)
        {
            min = i;
            for(int j = i+1;j < total;j++)
            {
                if(data[j] < data[min])
                {
                    min = j;
                }
            }
            if(min != i)
            {
                int temp = data[i];
                data[i] = data[min];
                data[min] = temp;
            }
        }
        System.out.println("选择排序后：");
        for (int i = 1; i < total; i++)
            System.out.print(data[i]+",");
    }
}

    public static void main(String[] args) {
        long now = System.currentTimeMillis();
choose choose1 = new choose();
choose1.choose_sort();

long now2 = System.currentTimeMillis();
        System.out.println();
        System.out.println(now2-now+"ms");
    }

结果：
在这里插入图片描述
在这里插入图片描述

6.堆排序

可以分两种情况分别讨论
①如果初始序列是堆,则可通过反复执行如下操作而最终得到一个有序序列
输出根:即将根(第一个元素)与当前子序列中的最后一个元素交换。
调整堆:将输出根之后的子序列调整为堆(元素个数比输出前少1个)元
②如果初始序列不是堆,则首先要将其先建成堆然后再按①的方式来实现
现在的问题是:如何由一个无序序列建成一个堆?
事实上,由无序序列建堆可通过反复调用筛选作来实现。为此需满足筛选的条件,即左右子树必须为堆。因此,建堆过程要从下往上逐子树地进行筛选。从易于编程的角度出发,根的下标自然是按从大到小,即按照根的下标从2到1的次序调整各子树为堆。
由初始序列(12,15,30,80,100,46,78,3390,86,64,55,120,230,45)建堆的过程如图11-9所示。

最终得到的堆：
（230,100,120,90,86,55,7833,80,15,64,12,46,30,45)
在这里插入图片描述
在这里插入图片描述
代码：

class Heap{

    int total = 100000;
    //Integer n = 100;解析为 Integer num = Integer.valueOf(100);
    //valueOf(参数)方法其实调用的是 new Integer(100);
    int[]data= new int[total];
    Heap(){
        Random random = new Random();
        for (int i = 0; i < total; i++)
            data[i] = random.nextInt(10000) %10000;
        for (int i = 0; i < total; i++)
            System.out.print(data[i]+",");
    }
    public void build(int begin,int end){//建立大根堆
        //end为最大元素下标
        //调整数组以begin为根的子树序列为根，其中最大的元素下标为end
        //假设以2k和2k+1为根的左右子树均为堆
               int i = begin;
               boolean finished = false;
               int j = 2*i;
               int temp = this.data[i];
               while(j<= end && !finished)
               {

                   if(j+1<=end && this.data[j+1] > this.data[j])
                       j = j+1;//指向左右孩子的最大值
                   if(this.data[i] < this.data[j])
                   {
                       this.data[i] = this.data[j];
                       i = j;
                       j = 2*j;
                   }
                   else finished = true;//如果原根最大，筛选结束
               }
               this.data[i] = temp;//原根的值填充到所搜索的当前空位置中
    }
    public void heap_sort(){
        for(int i = (total-1)/2;i>=0;i--)
        {
            build(i,total-1);//建立初始堆

        }
        System.out.println();

        for(int i = total-1;i>=1;i--)
        {
            int temp = this.data[0];
            this.data[0] = this.data[i];
            this.data[i] = temp;//先输出根
            build(0,i-1);//调整子序列data[0..i-1]

        };
        System.out.println("堆排序后");
        for (int i = 0; i < total; i++)
            System.out.print(data[i]+",");
    }
}

    public static void main(String[] args) {
        long now = System.currentTimeMillis();
Heap heap=new Heap();
heap.heap_sort();

long now2 = System.currentTimeMillis();
        System.out.println();
        System.out.println(now2-now+"ms");
    }

结果：
在这里插入图片描述

7.归并排序

 public static void main(String[] args) {
        long now = System.currentTimeMillis();
Merge merge = new Merge();
merge.merge_operation(0,merge.get()-1);
    System.out.println();
        for (int i = 0; i < merge.get(); i++)
            System.out.print(merge.data[i]+",");
long now2 = System.currentTimeMillis();
        System.out.println();
        System.out.println(now2-now+"ms");
    }
class Merge{
    int total = 100000;

   public int[]data= new int[total];
    Merge(){
        Random random = new Random();
        for (int i = 0; i < total; i++)
            data[i] = random.nextInt(10000) %10000;
        for (int i = 0; i < total; i++)
            System.out.print(data[i]+",");
    }
    public Integer get(){
        return this.total;
    }
    public void merge(int low, int mid, int high){

        int i = low;
        int j = mid + 1;
        int []tmp = new int[high - low +1];//分配足够空间
        int k = 0;
        while(j <= high && i <= mid)
        {
            if(data[i] >data[j])
            {

                tmp[k++] = data[j++];
            }
            else tmp[k++] = data[i++];
        }
        while(j <= high)
            tmp[k++] = data[j++];
        while(i <= mid)
            tmp[k++] = data[i++];
        for(int k1 = 0;k1 < k;k1++)
            data[low+k1] = tmp[k1];

    }
    public void merge_operation(int low,int high) {
        if (low < high) {
            int mid =(low + high)/2;
            merge_operation(low,mid);
            merge_operation(mid+1,high);
            merge(low,mid,high);
        }
    }
}

结果
在这里插入图片描述
还是比较快的，时间复杂度是o(nlogn)

march of Time
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中的各种数据结构和算法的比较
lx_Frolf的博客
10-22 1310
线性表相关： 线性表是一种逻辑结构，相同数据类型的N个数据元素的有限序列，除了第一个元素外，每个元素有且仅有一个直接前驱，除了最后一个元素外，每个元素有且仅有一个直接后继。 线性表的特点： 1.元素个数有限 2.逻辑上元素有先后次序 3.数据类型相同 4.仅讨论元素间的逻辑关系 线性表的层次关系： 栈和队列是两种操作受限的线性表：栈的插入和删除只能在表尾端进行，即栈顶；队列只能在表尾插入元素，在...
Java 七种排序算法实现
05-10
在编程领域，排序算法是数据结构与算法学习中的基础部分，尤其在Java中，掌握不同的排序算法对于优化程序性能至关重要。本资源包含了七种经典的排序算法实现，它们分别是冒泡排序、插入排序、递归排序（这里可能是指...
各类排序的性能及实现
m0_72000264的博客
05-11 162
Java排序方法中，分为基于比较的排序方法和非基于比较的排序方法。基于比较的排序方法适用于各类规模的数据，适用范围比较广。非基于比较的排序方法需要占用空间来确定其唯一位置，所以适用范围有限。不要求稳定，数据规模小，且数据无序的情况下，选择快速排序；要求稳定且数据规模小，数据有序的情况下，选择插入排序，数据无序的情况下，选择归并排序；若数据规模较大，选择快速排序，归并排序，或堆排序。
八大排序算法Java及性能比较
肩并肩的博客
11-30 1495
概述 排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 我们这里说说八大排序就是内部排序。          当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。    快速排序：是目前基于比较的内部排序中被认为是最好的方法，
java 性能 排序_java几种排序方式速度的简单测试?
weixin_34693167的博客
03-05 154
冒泡排序，选择排序，插入排序，快速排序1、冒泡排序是排序里面最简单的了，但性能也最差，数量小的时候还可以，数量一多，是非常慢的。public static void bubbleSort(int[] arr){for(int i=0;ifor(int j=0;jif(arr[j]>arr[j+1]){int temp =arr[j];arr[j]=arr[j+1];arr[j+1]=temp...
测试四种排序算法的性能（java版）
m0_57761313的博客
04-05 137
本次采用希尔排序、选择排序、插入排序、冒泡排序，测试十万条倒序的数字。再把十万条数据获取到数组里，方便后面使用。先倒叙生成十万条数据，打印到.txt里。
用java实现常用的排序算法以及这些算法的性能测试和比较
hongqiutiandi163的博客
09-07 1442
本文主要使用java实现选择排序，插入排序，冒泡排序，希尔排序，快速排序，归并排序，并对这些算法进行的性能的测试，从中窥探出各个算法的优劣，从而有助于在今后结合应用场景能够选择合适的排序算法。
七种排序算法Java版性能比较+Java实现.doc
09-21
本文将详细分析七种常见的Java排序算法：冒泡排序、选择排序、快速排序、插入排序、希尔排序、归并排序和堆排序，并探讨它们在不同条件下的性能表现。 1. **冒泡排序**： - 时间复杂度：平均和最坏情况下都是O(n^2...
java数据结构排序算法之树形选择排序详解
08-30
java数据结构排序算法之树形选择排序详解 树形选择排序是一种高效的排序算法，它可以降低比较次数，提高排序效率。下面我们将详细介绍树形选择排序的原理、实现技巧与相关注意事项。 树形选择排序的原理： 树形...
用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录.zip
最新发布
01-13
Java是一种高性能、跨平台的面向对象编程语言。它由Sun Microsystems（现在是Oracle Corporation）的James Gosling等人在1995年推出，被设计为一种简单、健壮、可移植、多线程、动态的语言。Java的主要特点和优势...
java 内部排序算法的性能分析
08-25
[问题描述] 设计一个测试程序比较几种内部排序算法的关键字比较次数和移动次数以取得直观感受。 [需求分析] (1)对起泡排序、直接排序、简单选择排序、快速排序、希尔排序、堆排序算法进行比较； (2)待排序表的表长不小于100，表中数据随机产生，至少用5组不同数据作比较，比较指标有：关键字参加比较次数和关键字的移动次数（关键字交换记为3次移动）； (3)输出比较结果。 [选做内容] (1)对不同表长进行比较； (2)验证各算法的稳定性； (3)输出界面的优化。
java实现数据结构常见排序算法及详解
11-08
详细讲述了8中常见算法的原理及思想，并用JAVA进行了实现，代码中有详细的注释，解释了算法的实现逻辑和一些小技巧。
java 性能 排序_排序算法java实现以及简易性能测试
weixin_39892842的博客
02-13 123
离上一篇博客已经一个星期了，一直想把学到的东西写出来，但总觉得领悟的不够透彻，想写点数据库事务吧，对每种隔离级别所对应的加锁情况以及mvcc只是一知半解；想学着别人写hashmap源码分析吧，看到红黑树，emmmmmmm等我把红黑树弄明白了再好好写一篇hashmap……那今天，先把八大排序算法实现一遍好了。在之前学数据结构时，八种排序算法大致流程都能弄明白(其实有几个还是有些误解的，捂脸)。上图的...
数据结构各类排序算法详解+代码分析
LRY89757的博客
06-30 1921
数据结构各类排序算法详解+代码分析 前言 不知不觉，数据结构已经学完了，博主也马上大二了????时间过得太快了????，但是数据结构学得确实不太好，楼主花了将近一天的时间整理了一下排序的有关算法。希望对大家也有所帮助。 目录数据结构各类排序算法详解+代码分析前言插入排序基本思想直接插入排序折半插入排序二路排序希尔排序快速排序选择排序基本思想简单选择排序锦标赛排序堆排序堆定义建堆堆排序算法代码解析归并排序基数排序总结排序方法比较方法选择写在后面 插入排序 基本思想 每步将一个待排序记录，按其关键码大小，插
数据结构与算法分析（一）—— 常见排序算法代码实现及性能分析
qq_39916709的博客
09-13 108
文章目录1 冒泡排序 1 冒泡排序
11 种 内部排序算法 大PK（Java 语言实现），究竟谁最快？
愿你饱经冷暖，仍保纯真
10-07 3116
11 种内部排序算法
各种排序算法的Java实现和性能对比
IT Crowd的博客
07-24 865
各种排序算法的Java实现和性能对比准备工作1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.归并排序6.希尔排序7.堆排序以上排序算法性能对比 准备工作 待排序数组：arr：[3,7,4,2,6] 数组元素交换函数： //交换数组中两个位置上的元素 public void swap(int[] arr,int i,int j) { int temp=arr[i]; arr[i...
常见排序的JAVA实现和性能测试
ColdCoding的博客
03-21 1648
写了五种常见的排序算法实现 算法描述 1.插入排序 从第一个元素开始，该元素可以认为已经被排序 取出下一个元素，在已经排序的元素序列中从后向前扫描 如果该元素（已排序）大于新元素，将该元素移到下一位置 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置 将新元素插入到该位置后 重复步骤2~5 在这个基础上有衍生出提高效率的二分插入排序2.冒泡排序 比较
Java8排序–性能陷阱
最佳 Java 编程
05-26 296
Java 8带来了lambda的所有优点，使我们能够使用声明式样式进行编程。 但这真的免费吗？ 我们是否应该担心必须为新的编程功能付出的代价？ 这是一个我们可能要担心的例子。 考虑对这个简单类的实例进行排序： private static class MyComparableInt{ private int a,b,c,d; public MyCo...
Java实现的10种基本排序算法详解
本文主要介绍了基于Java实现的10种基本排序方式，并对排序算法的稳定性、内外排序、时间复杂度和空间复杂度等概念进行了详细解释。 在计算机科学中，排序是处理数据的一种基本操作，它涉及到将一组数据按照特定顺序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值