八大排序Java写法

最新推荐文章于 2024-05-19 18:51:10 发布
最新推荐文章于 2024-05-19 18:51:10 发布
阅读量64 收藏
点赞数
文章标签： java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dsfxvbdfs/article/details/120256119
版权

各个排序的时间复杂度

图源学益得

 

1. 冒泡排序

//输出时间：20793ms
public class Bubble {
    public static void main(String[] args)
    {
        double[] array = new double[100000];

        for(int i=0; i<array.length; i++)
        {
            array[i] = Math.random();
        }

        long l1 = System.currentTimeMillis();
        bubbleSort(array);
        long l2 = System.currentTimeMillis();

        long l3 = l2-l1;
        System.out.println(l3);

//        for(int i=0; i<array.length; i++)
//        {
//            System.out.print(array[i]+" ");
//        }
    }

    public static void bubbleSort(double[] array)
    {
        double tmp = 0;

        for(int i=0; i<array.length-1; i++)
        {
            for(int j=0; j<array.length-1-i; j++)
            {
                if(array[j] > array[j+1])
                {
                    tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                }
            }
        }
    }
}

2. 直接插入排序

//直接插入排序，第一个for循环遍历所有数组元素，第二个for循环判断这个元素比前面元素大或者小，大就break，小就互换位置
//注意引入tmp变量保存第一个for遍历的元素，可以用break的原因是前面的j个元素已经按升序排列好了

//输出时间：1874ms
public class DirectInsert {
    public static void main(String[] args)
    {
        double[] array = new double[100000];
        for(int i=0; i<array.length; i++)
        {
            array[i] = Math.random();
        }

        long l1 = System.currentTimeMillis();
        directInsertSort(array);
        long l2 = System.currentTimeMillis();

        System.out.println(l2-l1);

//        for(int i=0; i<array.length; i++)
//        {
//            System.out.print(array[i]+" ");
//        }
    }

    public static void directInsertSort(double[] array)
    {
        double tmp = 0;
//        注意这里是从i=1开始进行比较！
        for(int i=1; i<array.length; i++)
        {
            tmp = array[i];
            for(int j=i-1; j>=0; j--)
            {
                if(tmp < array[j])
                {
                    array[j+1] = array[j];
                    array[j] = tmp;
                }
                else
                {
                    break;
                }
            }
        }
    }
}

3. 希尔排序

//输出时间：22ms
public class Shell {
    public static void main(String[] args)
    {
        double[] array = new double[100000];

        for(int i=0; i<array.length; i++)
        {
            array[i] = Math.random();
        }

        long l1 = System.currentTimeMillis();
        shellSort(array);
        long l2 = System.currentTimeMillis();

        long l3 = l2 - l1;
        System.out.println(l3);

//        for(int i=0; i<array.length; i++)
//        {
//            System.out.print(array[i]+" ");
//        }
    }

    public static void shellSort(double[] array)
    {
        double tmp = 0;

        for(int h = array.length/2; h>0; h/=2)
        {
            for(int i=h; i<array.length; i++)
            {
                tmp = array[i];
                for(int j=i-h; j>0; j-=h)
                {
                    if(tmp < array[j])
                    {
                        array[j+h] = array[j];
                        array[j] = tmp;
                    }
                    else
                    {
                        break;
                    }
                }
            }
        }
    }

}

4. 简单选择排序

// 在第二个if循环中选举出一个最小的元素，记录它的值和下标，然后把它和第一个if循环的array[i]做交换
//输出时间：7570ms
public class SimpleChoosing {
    public static void main(String[] args)
    {
        double[] array = new double[20];

        for(int i=0; i<array.length; i++)
        {
            array[i] = Math.random();
        }

        long l1 = System.currentTimeMillis();
        bubbleSort(array);
        long l2 = System.currentTimeMillis();

        long l3 = l2-l1;
        System.out.println(l3);

        for(int i=0; i<array.length; i++)
        {
            System.out.print(array[i]+" ");
        }
    }

    public static void bubbleSort(double[] array)
    {
        double tmp = 0;
        double tmp2 = 0;
        int index = 0;


        for(int i=0; i<array.length; i++)
        {
            tmp = array[i];
            index = i;
            for(int j=i+1; j<array.length; j++)
            {
                if(array[j] < tmp)
                {
                   tmp = array[j];
                   index = j;
                }
            }
                tmp2 = array[index];
                array[index] = array[i];
                array[i] = tmp2;

        }
    }
}

5. 快速排序

//输出时间：46ms
public class Fast {
    public static void main(String[] args)
    {
        double[] array = new double[100000];

        for(int i=0; i<array.length; i++)
        {
            array[i] = Math.random();
        }


        long l1 = System.currentTimeMillis();
        fastSort(array, 0, array.length-1);
        long l2 = System.currentTimeMillis();

        long l3 = l2-l1;
        System.out.println(l3);

//        for(int i=0; i<array.length; i++)
//        {
//            System.out.print(array[i]+" ");
//        }
    }

    public static void fastSort(double[] array, int begin, int end)
    {
//        注意这里的if，和视频里面用C写的不一样！
        if(end > 0 && begin < end)
        {
            int x = begin;
            int y = end;
            double tmp = array[begin];

            while(x < y)
            {
                while(tmp < array[y] && x < y)
                {
                    y--;
                }
                if(x < y)
                {
                    array[x] = array[y];
                    x++;
                }
                while(tmp > array[x] && x < y)
                {
                    x++;
                }
                if(x < y)
                {
                    array[y] = array[x];
                    y--;
                }
            }
            array[x] = tmp;

            fastSort(array, begin, x-1);
            fastSort(array, x+1, end);
        }
    }
}

6. 堆排序

//先构建大顶堆（比较数组下标从长度一半的值-1到0的所有孩子节点），然后把最大的第一个元素放在最后一个位置。再构建除了后面的元素之外其它的元素的顶堆，
// 此时只用以第一个元素开头构建顶堆，然后把第一个元素放在此时的“最后一个”元素的位置，如此反复一下去

//输出时间：17ms
public class Heap {

    public static void main(String[] args)
    {
        double[] array = new double[100000];

        for(int i=0; i<array.length; i++)
        {
            array[i] = Math.random();
        }

        long l1 = System.currentTimeMillis();
        heapSort(array);
        long l2 = System.currentTimeMillis();

        long l3 = l2 - l1;

        System.out.println(l3);


//        for(int i=0; i<array.length; i++)
//        {
//            System.out.print(array[i]+" ");
//        }
    }

    public static void heapSort(double[] array)
    {
        double tmp = 0;
        int i;
        for(i = (array.length/2)-1; i>=0; i--)
        {
            constructHeap(array, i, array.length-1);
        }

        for(i = array.length-1; i>0; i--)
        {
            tmp = array[0];
            array[0] = array[i];
            array[i] = tmp;
            constructHeap(array, 0, i-1);
        }
    }

    public static void constructHeap(double[] array, int root, int last)
    {
        int child = 0;
        double tmp = array[root];

        for(; 2*root+1 <= last; root = child)
        {
            child = 2*root + 1;
            if(child + 1 <= last && array[child] < array[child + 1])
            {
                child++;
            }

            if(array[child] > array[root])
            {
                array[root] = array[child];
                array[child] = tmp;
            }
        }
    }


}

7. 归并排序

//输出时间：33ms
public class Merge {
    public static void main(String[] args)
    {
        double[] array = new double[100000];
        for(int i=0; i<array.length; i++)
        {
            array[i] = Math.random();
        }

        long l1 = System.currentTimeMillis();
        mergeSort(array, 0, array.length-1);
        long l2 = System.currentTimeMillis();

        long l3 = l2 - l1;
        System.out.println(l3);


//        for(int i=0; i<array.length; i++)
//        {
//            System.out.print(array[i]+" ");
//        }
    }

    public static void mergeSort(double[] array, int begin, int end)
    {
        if(begin >= end)
        {
            return;
        }

        int mid = (begin + end)/2;
        mergeSort(array, begin, mid);
        mergeSort(array, mid+1, end);

        merge(array, begin, mid, end);
    }

    public static void merge(double[] array, int begin, int mid, int end)
    {

        int leftLength = mid - begin + 1;
        int rightLength = end - mid;

        int i = 0;
        int j = 0;
//        注意这里k为什么等于begin而不是0，而i、j等于0
        int k = begin;

        double[] leftArray = new double[leftLength];
        double[] rightArray = new double[rightLength];

        for(i=0, k=begin; i<leftLength; i++, k++)
        {
            leftArray[i] = array[k];
        }

        for(j=0; j<rightLength; j++, k++)
        {
            rightArray[j] = array[k];
        }

        for(i=0, j=0, k=begin; i<leftLength && j<rightLength; k++)
        {
            if(leftArray[i] < rightArray[j])
            {
                array[k] = leftArray[i];
                i++;
            }
            else
            {
                array[k] = rightArray[j];
                j++;
            }

        }

        if(j<rightLength)
        {
            for(; j<rightLength; j++)
            {
                array[k] = rightArray[j];
                k++;
            }
        }
        if(i<leftLength)
        {
            for(; i<leftLength; i++)
            {
                array[k] = leftArray[i];
                k++;
            }
        }

    }
}

8. 基数排序

//输出时间：40ms
public class Radix {
    public static void main(String[] args) throws ArrayIndexOutOfBoundsException
    {
        double[] array = new double[100000];
        for(int i=0; i<array.length; i++)
        {
            array[i] = 100*Math.random();
        }

        long l1 = System.currentTimeMillis();
        radixSort(array);
        long l2 = System.currentTimeMillis();

        long l3 = l2-l1;
        System.out.println(l3);

//        for(int i=0; i<array.length; i++)
//        {
//            System.out.print(array[i] + " ");
//        }
    }

    public static void radixSort(double[] array)
    {
        int i = 0;
        double max = array[0];
        int base = 1;

        for(i=1; i<array.length; i++)
        {
            if(array[i] > max)
            {
                max = array[i];
            }
        }

        double[] array2 = new double[array.length];


        while(max / base > 0)
        {
            int[] bucket = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
//            比较个位/十位/百位/千位...桶的0-9元素加1
            for(i=0; i<array.length; i++)
            {
                bucket[(int)(array[i] / base) % 10 ]++;
            }
//          为了确定各个元素放入array2的顺序，需要借助桶的个数并且作修改，来获取每个元素的下标
            for(i=1; i<10; i++)
            {
                bucket[i] = bucket[i] + bucket[i-1];
            }
//          先通过array的个位/十位/百位/千位对应的数字获取对应的桶元素，然后将这个桶元素-1获得array要放入array2的下标。由于每个桶元素不止
//          对应着一个array的元素，所以每次放入后要将桶元素减1
            for(i=array.length-1; i>=0; i--)
            {
                array2[bucket[((int)array[i] / base) % 10] - 1] = array[i];
                bucket[(int)(array[i] / base) % 10]--;
            }

//          最后将array2的元素重新放回array中，完成一次个位/十位/百位...的基数排序
            for(i=0; i<array.length; i++)
            {
                array[i] = array2[i];
            }

//          base自乘10，准备下一位的基数排序
            base = base * 10;
        }
    }

}

晏楚
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
用java写的常见排序
码莎拉蒂
08-19 1378
/** * @author Think *折半插入排序 */ public class binInsertSort { private static int a[]={22,3,43,11,99,88,34,34,33,22,11,1}; public static void main(String[] args) { int []b=binInsertSo
所有排序的写法（Java）.zip
12-01
直接选择排序、堆排序、冒泡排序、快速排序、直接插入排序、折半插入排序、Shell排序、归并排序、桶式排序、基数排序
Java 常见排序的写法
ladykiller21的博客
03-07 222
public class Demo { public static void main(String[] args) { int arr[] = { 12, 4, 67, 22, 5, 88, 1 }; quickSort(arr); for(int x : arr) System.out.println(x); ...
Java实现各种简单排序
路人甲的博客
03-20 594
Java实现各类排序
java 简单排序_简单排序之java实现
weixin_35025310的博客
02-25 208
3种顺序排序方法。简单排序是指时间复杂度为O(n^2)的排序方法。1)选择排序将某个特定值有序的放置在最终位置上---外层循环控制最终位置的序号，内层循环从外层循环序号处向后遍历，找到最小值。2)插入排序插入排序将某个特定值插入到值列的某个子集中，并重复该过程---外层循环控制要插入的数据(从第二个数到最后一个)，内层循环控制前面已排好序的的值后移。3)冒泡排序重复比较相邻的两个元素，并在必要的时...
Java数组与八大排序
缘友一世的博客
06-26 505
浅谈数组 数组初始化 知识捡漏静态初始化写法 数组操作：反转 二维数组 数组的练习：根据数组元素查找该元素第一次在数组中出现的索引 方法1：挨个遍历查找法 方法2：二分查找法 二 数组常见的八大排序方法 2.1 冒泡排序 图解 举个栗子 2.2 选择排序 图解 举个栗子 2.3 插入排序 2.4 希尔排序【基于插入排序，大大提高插入排序的执行效率】 正常序列 伯努利序列 2.5 快速排序 原理 实现思路 2.6 归并排序 2.7 基数排序 2.7 堆排序...
关于冒泡排序的写法
08-17
Java最常见的面试问题就是冒泡排序，这种排序算法经常考，希望读者能够用到
详解Java中clone的写法
08-27
主要介绍了Java中clone的写法,非常不错，具有一定的参考借鉴价值，需要的朋友可以参考下
关于动态规划求最大子段和的Java代码写法
07-02
求最大子段和
ThreadPool:java线程池的写法
06-11
线程池 java线程池的写法 这个类展示了在java中实现ThreadPool的一种方式！ 您可以轻松阅读源文件，因为注释很详细。 尽情享受吧！
jar包增量更新分析
junlaiyan的专栏
05-16 285
借助jdeps分析出jar包的增量文件
docker中安装jenkins，并在node和cloud上跑通基于源码控制SCM的pipeline
最新发布
qq_29022265的博客
05-19 1053
从安装jenkins到创建jenkins的node和cloud，最后再将scm和FreeStyle两种流水线跑通。
Spring-Cloud 微服务
weixin_65127444的博客
05-15 913
先来思考一个问题*通过上一章的操作，我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址（ip，端口）等硬编码到了代码中，这种做法存在许多问题：1.一旦服务提供者地址变化，就需要手工修改代码2. 一旦是多个服务提供者，无法实现负载均衡功能3.一旦服务变得越来越多，人工维护调用关系困难那么应该怎么解决呢，这时候就需要通过注册中心动态的实现。
java实现拼图小游戏
monkey108的博客
05-16 644
本文主要提供用java实现的拼图小游戏源代码。
命令执行漏洞（二）
XLbb的博客
05-15 917
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 256
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
SpringMVC基础
Java小白的博客 致力分享每一天学到的知识
05-15 1311
介绍了有关SpringMVC的基础内容
C++ 11
qq_65112813的博客
05-17 662
对于类类型，如果定义了接受。
Kubernetes 审计日志采集与分析最佳实践
观测云的博客
05-17 1029
​Kubernetes 在 1.7 版本中发布了审计（Audit）日志功能，通过审计日志，我们能够非常清晰的知道 K8S 集群到底发生了什么事情。
Java 冒泡排序写法
03-07
Java 冒泡排序的写法如下： ``` public static void bubbleSort(int[] arr) { int n = arr.length; for (int i = ; i ; i++) { for (int j = ; j ; j++) { if (arr[j] > arr[j + 1]) { int temp = arr[j]; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值