精华内容
下载资源
问答
  • Java排序算法

    2019-11-06 22:15:53
    Java排序算法 排序算法(二) 排序算法(三) 排序算法(四) 排序算法(五)-双调排序 排序算法(六)-TimSort 排序算法(七)-双轴快速排序 排序算法(八)-三路快速排序 排序算法(九)-Java源码中的...
    展开全文
  • java排序算法

    千次阅读 2018-08-19 10:39:14
    java常用排序算法 1,冒泡排序 特点:效率低,实现简单 思想:每一趟将待排序序列中最大元素移到最后,剩下的为新的待排序序列,重复上述步骤直到排完所有元素。这只是冒泡排序的一种,当然也可以从后往前排。 ...

    java常用排序算法

    1,冒泡排序
    特点:效率低,实现简单
    思想:每一趟将待排序序列中最大元素移到最后,剩下的为新的待排序序列,重复上述步骤直到排完所有元素。这只是冒泡排序的一种,当然也可以从后往前排。

    public void bubbleSort(int array[]) {
            int t = 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]) {
                        t = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = t;
                    }
        }

    2,选择排序
    特点:效率低,容易实现。
    思想:每一趟从待排序序列选择一个最小的元素放到已排好序序列的末尾,剩下的为待排序序列,重复上述步骤直到完成排序。

    public void selectSort(int array[]) {
            int t = 0;
            for (int i = 0; i < array.length - 1; i++){
                int index=i;
                for (int j = i + 1; j < array.length; j++)
                    if (array[index] > array[j])
                        index=j;
                if(index!=i){ //找到了比array[i]小的则与array[i]交换位置
                    t = array[i];
                    array[i] = array[index];
                    array[index] = t;
                }
            }
        }

    3,插入排序
    特点:效率低,容易实现。
    思想:将数组分为两部分,将后部分元素逐一与前部分元素比较,如果前部分元素比array[i]小,就将前部分元素往后移动。当没有比array[i]小的元素,即是合理位置,在此位置插入array[i]

    public void insertionSort(int array[]) {
            int i, j, t = 0;
            for (i = 1; i < array.length; i++) {
                t = array[i];
                for (j = i - 1; j >= 0 && t < array[j]; j--)
                    array[j + 1] = array[j];
                //插入array[i]
                array[j + 1] = t;
            }
      }
    
    

    4,快速排序
    特点:高效,时间复杂度为nlogn。
    采用分治法的思想:首先设置一个轴值pivot,然后以这个轴值为划分基准将待排序序列分成比pivot大和比pivot小的两部分,接下来对划分完的子序列进行快排直到子序列为一个元素为止。

    public void quickSort(int array[], int low, int high) {// 传入low=0,high=array.length-1;
            int pivot, p_pos, i, t;// pivot->位索引;p_pos->轴值。
            if (low < high) {
                p_pos = low;
                pivot = array[p_pos];
                for (i = low + 1; i <= high; i++)
                    if (array[i] > pivot) {
                        p_pos++;
                        t = array[p_pos];
                        array[p_pos] = array[i];
                        array[i] = t;
                    }
                t = array[low];
                array[low] = array[p_pos];
                array[p_pos] = t;
                // 分而治之
                quickSort(array, low, p_pos - 1);// 排序左半部分
                quickSort(array, p_pos + 1, high);// 排序右半部分
         }
    展开全文
  • 常见几种java排序算法

    万次阅读 多人点赞 2019-02-18 18:08:16
    1.插入排序 public class InsertSort { public static void sort(int[] arr) { if (arr.length &amp;amp;amp;gt;= 2) { for (int i = 1; i &amp;amp;amp;lt; arr.length; i++) { //挖出一个要用来插入...

    1.插入排序

    这个打麻将或者打扑克的很好理解, 比如有左手有一副牌1,2,4,7 ,来一张3的牌, 是不是就是手拿着这张牌从右往左插到2,4之间

    一次插入排序的操作过程:
    将待插元素,依次与已排序好的子数列元素从后到前进行比较,如果当前元素值比待插元素值大,则将移位到与其相邻的后一个位置,否则直接将待插元素插入当前元素相邻的后一位置,因为说明已经找到插入点的最终位置
    在这里插入图片描述

    public class InsertSort {
    
        public static void sort(int[] arr) {
            if (arr.length >= 2) {
                for (int i = 1; i < arr.length; i++) {
                    //挖出一个要用来插入的值,同时位置上留下一个可以存新的值的坑
                    int x = arr[i];
                    int j = i - 1;
                    //在前面有一个或连续多个值比x大的时候,一直循环往前面找,将x插入到这串值前面
                    while (j >= 0 && arr[j] > x) {
                        //当arr[j]比x大的时候,将j向后移一位,正好填到坑中
                        arr[j + 1] = arr[j];
                        j--;
                    }
                    //将x插入到最前面
                    arr[j + 1] = x;
                }
            }
        }
    }
    

    2.分治排序法,快速排序法

    简单的说, 就是设置一个标准值, 将于这个值的放到右边(不管排序), 将于这个值的放到左边(不管排序), 那么这样只是区分了左小右大, 没有排序, 没关系, 左右两边再重复这个步骤.直到不能分了为止.
    详细说就是:

    1. 选择待排数列的首部第一个元素为基准元素x,设置两指针,分别指向数列首尾部位置,假设两指针分别设为ij
    2. 每次遍历的过程是这样的,首先从右到左遍历指针j所指向的元素,直到j指向的元素值小于基准元素x时,停止遍历,将其放到i的位置(因为i的值已经拷贝成了基准x腾出了位置)
    3. i往右挪一步, i++,接着轮到指针i左到右遍历,直到i所指向的元素值大于基准元素x时,停止遍历,将其放到j的位置(因为上面一步j的值已经占用到了i的位置,腾出位置了)
    4. 依此类推,两边轮流遍历, 直到指针i与指针j相等或者大于(实际肯定是i==j)时,停止外部循环。此时必定左边都是比x小的, 右边是比x大的.
    5. 最后直接将基准元素x直接放置于指针i所指向的位置即可
    6. 完成分区操作, 从i的位置一分为二, 左边和右边再递归执行上面的操作. 层层细分

    接下来,我们通过示图来展示上述分区算法思路的过程:
    在这里插入图片描述

    public class QuickSort {
    
        public static void sort(int[] arr,int begin,int end) {
            //先定义两个参数接收排序起始值和结束值
            int a = begin;
            int b = end;
            //先判断a是否大于b
    
            if (a >= b) {
                //没必要排序
                return;
            }
            //基准数,默认设置为第一个值
            int x = arr[a];
    
            //循环
            while (a < b) {
                //从后往前找,找到一个比基准数x小的值,赋给arr[a]
                //如果a和b的逻辑正确--a<b ,并且最后一个值arr[b]>x,就一直往下找,直到找到后面的值大于x
                while (a < b && arr[b] >= x) {
                    b--;
                }
                //跳出循环,两种情况,一是a和b的逻辑不对了,a>=b,这时候排序结束.二是在后面找到了比x小的值
                if (a < b) {
                    //将这时候找到的arr[b]放到最前面arr[a]
                    arr[a] = arr[b];
                    //排序的起始位置后移一位
                    a++;
                }
    
                //从前往后找,找到一个比基准数x大的值,放在最后面arr[b]
                while (a < b && arr[a] <= x) {
                    a++;
                }
                if (a < b) {
                    arr[b] = arr[a];
                    //排序的终止位置前移一位
                    b--;
                }
            }
            //跳出循环 a < b的逻辑不成立了,a==b重合了,此时将x赋值回去arr[a]
            arr[a] = x;
            //调用递归函数,再细分再排序
            sort(arr,begin,a-1);
            sort(arr,a+1,end);
        }
    }
    

    3.冒泡排序 low版

    每次冒泡过程都是从数列的第一个元素开始,然后依次和剩余的元素进行比较, 跟列队一样, 从左到右两两相邻的元素比大小, 高的就和低的换一下位置. 最后最高(值最大)的肯定就排到后面了.

    但是这只是把最高的排到后面了, 还得找出第二高的, 于是又从第一个开始两两比较, 高的往后站, 然后第二高的也到后面了.

    然后是第三高的再往后排…
    在这里插入图片描述

    public class MaoPao {
    
        public static void  sort(int[] arr){
            for (int i = 1; i < arr.length; i++) {  //第一层for循环,用来控制冒泡的次数
                for (int j = 0; j < arr.length-1; j++) { //第二层for循环,用来控制冒泡一层层到最后
                    //如果前一个数比后一个数大,两者调换 ,意味着泡泡向上走了一层
                    if (arr[j] > arr[j+1] ){
                        int temp = arr[j];
                        arr[j] = arr[j+1];
                        arr[j+1] = temp;
                    }
                }
            }
        }
    }
    
    

    4.冒泡排序 bigger版

    补充, 改进后,看下文的测试结果发现提升并不大, 这是正常的, 因为改进后省略的是排序成功后的判断步骤, 而就算没改进, 排序成功后也只不过是对数组进行遍历而已, 没有进行数据更新操作, 而我们知道数组是读取快更新慢的, 所以和上面的版本相比看起来提升不算大

    在这个版本中,改动了两点

    1. 第一点是加入了一个布尔值,判断第二层循环中的调换有没有执行,如果没有进行两两调换,说明后面都已经排好序了,已经不需要再循环了,直接跳出循环,排序结束.
    2. 第二点是第二层循环不再循环到arr.length - 1,因为外面的i循环递增一次,说明数组最后就多了一个排好序的大泡泡.第二层循环也就不需要到最末尾一位了,可以提前结束循环
     /**
     * 终极版冒泡排序
     * 加入一个布尔变量,如果内循环没有交换值,说明已经排序完成,提前终止
     * @param arr
     */
    public static void sortPlus(int[] arr){
        if(arr != null && arr.length > 1){
            for(int i = 0; i < arr.length - 1; i++){
                // 初始化一个布尔值
                boolean flag = true;
                for(int j = 0; j < arr.length - i - 1 ; j++){
                    if(arr[j] > arr[j+1]){
                        // 调换
                        int temp;
                        temp = arr[j];
                        arr[j] = arr[j+1];
                        arr[j+1] = temp;
                        // 改变flag
                        flag = false;
                    }
                }
                if(flag){
                    break;
                }
            }
        }
    }
    
    

    5.选择排序

    选择排序也是一种简单直观的排序算法,实现原理比较直观易懂:
    首先在未排序数列中找到最小元素,然后将其与数列的首部元素进行交换,然后,在剩余未排序元素中继续找出最小元素,将其与已排序数列的末尾位置元素交换。以此类推,直至所有元素圴排序完毕.

    同理,可以类比与打扑克和打麻将, 和上面插入排序不同, 插入排序相当于抽一张牌整理好了再抽一张, 而选择排序相当于一次性给你一副乱牌, 然后慢慢整理的感觉.
    这也容易理解为什么选择排序为啥比插入排序慢了. 插入排序是摸一张牌, 然后直接插入到手中已经排好序的牌,再摸下一张牌.
    选择排序相当于在一堆牌中, 不断的找到最小的牌往前面放.

    在这里插入图片描述

    public static void sort(int[] arr){
        for(int i = 0; i < arr.length - 1 ; i++){
            int min = i; // 遍历的区间最小的值
            for (int j = i + 1; j < arr.length ;j++){
                 if(arr[j] < arr[min]){
                     // 找到当前遍历区间最小的值的索引
                     min = j;
                 }
            }
            if(min != i){
                // 发生了调换
                int temp =  arr[min];
                arr[min] = arr[i];
                arr[i] = temp;
            }
        }
    }
    

    6. 归并排序

    归并排序,简单的说把一串数,从中平等分为两份,再把两份再细分,直到不能细分为止,这就是分而治之的分的步骤. 再从最小的单元,两两合并,合并的规则是将其按从小到大的顺序放到一个临时数组中,再把这个临时数组替换原数组相应位置,这就是治. 图解如下:

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    代码:

    public static void mergeSort(int[] a,int s,int e){
        int m = (s + e) / 2;
        if (s < e){
          mergeSort(a,s,m);
          mergeSort(a,m+1,e);
          //归并
          merge(a,s,m,e);
        }
      }
    
      private static void merge(int[] a, int s, int m, int e) {
        //初始化一个从起始s到终止e的一个数组
        int[] temp = new int[(e - s) + 1];
        //左起始指针
        int l = s;
        //右起始指针
        int r = m+1;
        int i = 0;
        //将s-e这段数据在逻辑上一分为二,l-m为一个左边的数组,r-e为一个右边的数组,两边都是有序的
        //从两边的第一个指针开始遍历,将其中小的那个值放在temp数组中
        while (l <= m && r <= e){
          if (a[l] < a[r]){
            temp[i++] = a[l++];
          }else{
            temp[i++] = a[r++];
          }
        }
    
        //将两个数组剩余的数放到temp中
        while (l <= m){
          temp[i++] = a[l++];
        }
        while (r <= e){
          temp[i++] = a[r++];
        }
        
        //将temp数组覆盖原数组
        for (int n = 0; n < temp.length; n++) {
          a[s+n] = temp[n];
        }
        
      }
    

    7. 其他排序

    比如Arrays工具类提供的排序方法。它内部实现也是快速排序

    private static void arraysSort(int[] a){
        Arrays.sort(a);
      }
    

    还有就是将数组转为list,使用集合的排序方法,但是这无异于兜圈子,因为集合底层也是数组

    private static void listSort(int[] a){
        List<Integer> integers = Ints.asList(a);
        Collections.sort(integers);
        integers.toArray(new Integer[a.length]);
      }
    

    7. 比较

    试了一下几个排序的速度,代码如下:

    public static void main(String[] args) {
    
        int[] arr = new int[200000];
        int[] a =getRandomArr(arr);
        int[] b = a.clone();
        int[] c = b.clone();
        int[] d = b.clone();
        int[] e = b.clone();
        int[] f = b.clone();
        int[] g = b.clone();
        int[] h = b.clone();
    
        long s = Clock.systemDefaultZone().millis();
        quickSort(a, 0, a.length - 1);
        System.out.println("quickSort耗时: " + (Clock.systemDefaultZone().millis() - s) + " ms");
    
        s = Clock.systemDefaultZone().millis();
        mergeSort(b,0,b.length-1);
        System.out.println("mergeSort: " + (Clock.systemDefaultZone().millis() - s) + " ms");
    
        s = Clock.systemDefaultZone().millis();
        listSort(c);
        System.out.println("listSort耗时: " + (Clock.systemDefaultZone().millis() - s) + " ms");
    
        s = Clock.systemDefaultZone().millis();
        arraysSort(d);
        System.out.println("arraysSort耗时: " + (Clock.systemDefaultZone().millis() - s) + " ms");
    
        s = Clock.systemDefaultZone().millis();
        maoPaoSort(e);
        System.out.println("maoPaoSort耗时: " + (Clock.systemDefaultZone().millis() - s) + " ms");
    
        s = Clock.systemDefaultZone().millis();
        maoPaoSortPlus(f);
        System.out.println("maoPaoSortPlus耗时: " + (Clock.systemDefaultZone().millis() - s) + " ms");
    
        s = Clock.systemDefaultZone().millis();
        insertSort(g);
        System.out.println("insertSort耗时: " + (Clock.systemDefaultZone().millis() - s) + " ms");
    
        s = Clock.systemDefaultZone().millis();
        selectSort(h);
        System.out.println("selectSort耗时: " + (Clock.systemDefaultZone().millis() - s) + " ms");
    
    
    
    }
    
    /**
       * 获取一个打乱的数组
       * @param arr
       */
      private static int[] getRandomArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
          arr[i] = new Random().nextInt(arr.length);
        }
        return arr;
      }
    

    分别对1k,1w,10w,20w大小的随机数组排序,结果如下:
    得到综合结果是:
    速度: 快速排序>>归并排序>>>>>插入排序>>选择排序>>冒泡排序
    并且可以看到,选择排序,冒泡排序在数据量越来越大的情况下,耗时已经呈指数型上涨,而不是倍数上涨,在50w的时候已经需要足足5分钟以上

    //---1k---
    quickSort耗时: 0 ms
    mergeSort: 1 ms
    listSort耗时: 7 ms
    arraysSort耗时: 1 ms
    maoPaoSort耗时: 3 ms
    maoPaoSortPlus耗时: 4 ms
    insertSort耗时: 2 ms
    selectSort耗时: 3 ms
    //---1w---
    quickSort耗时: 2 ms
    mergeSort: 3 ms
    listSort耗时: 19 ms
    arraysSort耗时: 4 ms
    maoPaoSort耗时: 166 ms
    maoPaoSortPlus耗时: 122 ms
    insertSort耗时: 12 ms
    selectSort耗时: 52 ms
    
    //---10w---
    quickSort耗时: 14 ms
    mergeSort: 19 ms
    listSort耗时: 65 ms
    arraysSort耗时: 12 ms
    maoPaoSort耗时: 15242 ms
    maoPaoSortPlus耗时: 15044 ms
    insertSort耗时: 797 ms
    selectSort耗时: 4073 ms
    //---20w---
    quickSort耗时: 26 ms
    mergeSort: 34 ms
    listSort耗时: 102 ms
    arraysSort耗时: 60 ms
    maoPaoSort耗时: 60811 ms
    maoPaoSortPlus耗时: 60378 ms
    insertSort耗时: 3279 ms
    selectSort耗时: 15762 ms
    
    展开全文
  • java排序算法总结

    千次阅读 多人点赞 2019-04-19 12:30:20
    java排序算法总结 排序,这是一个很古老但是又很经典的问题,世界上有很多中优秀排序算法的实现,在这里,我总结了其他比较常用的几种排序算法 1.java排序算法一览 冒泡排序和基数排序 桶排序和计数排序 归并排序和...

    java排序算法总结

    排序,这是一个很古老但是又很经典的问题,世界上有很多中优秀排序算法的实现,在这里,我总结了其他比较常用的几种排序算法

    1.java排序算法一览

    1. 冒泡排序和基数排序
    2. 桶排序和计数排序
    3. 归并排序和快速排序
    4. 堆排序
    5. 插入排序和希尔排序

    2.分类

    在这里插入图片描述

    3.比较

    1.时间复杂度比较

    算法 乱序时间复杂度 有序时间复杂度
    插入排序 O(N^2) O(N)
    希尔排序 O(N^2) O(N)
    冒泡排序 O(N^2) O(N)
    基数排序 O(N) O(N)
    桶排序 O(N)
    计数排序 O(N)
    归并排序 O(NlogN) O(NlogN)
    快速排序 O(NlogN) O(N^2)
    堆排序 O(NlogN)

    2.空间复杂度比较

    算法 空间复杂度
    插入排序 O(1)
    希尔排序 O(1)
    冒泡排序 O(1)
    基数排序 O(N)
    桶排序 O(N+M) M是额外辅助空间(桶数量)
    计数排序 O(N)
    归并排序 O(N)
    快速排序 O(1)
    堆排序 O(1)
    展开全文
  • 闲来无事回顾复习一下Java排序算法,以前也学过,不过一段时间之后发现对于排序算法记忆不是那么清晰,为加强记忆,特在此做一下笔记,以巩固基础,并与各位朋友分享一下,如有错误请指正,谢谢。冒泡排序法 Bubble ...
  • java 排序算法可视化 演示程序。 用java做的一个小的排序算法演示程序,用线程控制访问,共7个算法,包括冒泡,选择,希尔,插入,归并,堆,快排。。 算法排序
  • Java 排序算法-冒泡排序及其优化

    千次阅读 2020-03-15 01:11:06
    Java 排序算法-冒泡排序及其优化 Java 排序算法-冒泡排序及其优化什么是冒泡排序基本写法优化后写法终极版本源码及测试 什么是冒泡排序 这里引用一下百度百科上的定义: 冒泡排序(Bubble Sort),是一种计算机科学...
  • 该工具包含有Java一些比较常见的排序算法和查找算法。 排序算法包括:冒泡排序、选择排序 、插入排序、希尔排序、快速排序、归并排序、基数排序(桶排序) 查找算法包括:线性查找、二分查找、插值查询、斐波那契...
  • JAVA排序算法之希尔排序

    千次阅读 2019-10-17 09:25:14
    希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至 1 时,整个文件恰被分成一组,算法便终止 希尔排序法的示意图 代码实...
  • java排序算法之(冒泡排序法)

    千次阅读 2007-04-16 21:13:00
    java排序算法之(冒泡排序法) package sort;public class BubbleSort { /** * @author Bill.hu * @version 1.0 ,2007-4-16 * @param args */ public static void main(String[] args) { // TODO 自动生成方法...
  • import java.util.Random; /** * 排序测试类 * * 排序算法的分类如下: * 1.插入排序(直接插入排序、折半插入排序、希尔排序); * 2.交换排序(冒泡泡排序、快速排序); * 3.选择排序(直接选择排序、堆排序);
  • JAVA排序算法之插入排序

    千次阅读 2019-10-17 09:20:05
    插入式排序属于内部排序法,是对于欲排序的元素以插入的方式找寻该元素的适当位置,以达到排序的目的。 插入排序法思想: 插入排序(Insertion Sorting)的基本思想是:把 n 个待排序的元素看成为一个有序表和一个无序表...
  • 本章介绍Java经典排序算法中的冒泡排序,欢迎各位同学转载,但转载务必注明出处:https://blog.csdn.net/qq_35101450/article/details/89072688,谢谢~ 什么是冒泡排序 冒泡排序,算法如其名,我们可以把要排序的...
  • java排序算法,排序都有哪几种算法? 排序的算法有分别有: 1、插入排序 (直接插入排序、希尔排序) 2、交换排序(冒泡排序、快速排序) 3、选择排序(直接选择排序、堆排序) 4、归并排序 5、分配排序(箱...
  • Java排序算法总结(四):希尔排序

    千次阅读 2013-11-16 21:47:35
    Java排序算法总结(四):希尔排序  前言:希尔排序(Shell Sort)是插入排序的一种。是针对直接插入排序算法的改进。该方法又称缩小增量排序,  因DL.Shell于1959年提出而得名。本文主要介绍希尔排序用Java是...
  • java排序算法(一)冒泡排序

    万次阅读 2017-03-27 12:06:08
    java排序算法—冒泡排序。何为冒泡,举个栗子:观察气泡在水中的变化,气泡在底部时较小,当气泡慢慢浮出水面,气泡越来越大。冒泡排序又称交换排序。 冒泡排序的比较方式是从第一个元素开始,依次比较相邻的元素,...
  • java语言编写的排序算法,包括选择排序、插入排序、自底向上排序法、快速排序法等四种排序算法
  • Java排序算法总结(三):冒泡排序

    千次阅读 2013-11-16 21:41:53
    Java排序算法总结(三):冒泡排序 前言:冒泡排序(BubbleSort)就是依次比较相邻的两个数,将小数放在前面,大数放在后面。  下面让我们一起 来看冒泡排序在Java中的算法实现。    冒泡排序是计算机...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 310,103
精华内容 124,041
关键字:

java排序算法

java 订阅