数组排序_数组排序java - CSDN
  • 数组排序方法

    2018-11-19 19:52:52
    冒泡排序 **排序思想:**相邻元素两两比较,大的往后放,第一次完毕,最大值出现在了最大索引处。 选择排序 **排序思想:**第一个数依次与后面的数比较,第一次比较完之后最小的数在最前面 。如果前面的数大于...

    冒泡排序

    **排序思想:**相邻元素两两比较,大的往后放,第一次完毕,最大值出现在了最大索引处。
    在这里插入图片描述

    选择排序

    **排序思想:**第一个数依次与后面的数比较,第一次比较完之后最小的数在最前面 。如果前面的数大于后面的数,就进行位置的交换。

      public class Dome2 {
                                public static void main(String[] args) {
                                     //数组
                                     int[] arr = {5,3,7,2,6,7,6,5,4,1,9,8};
                                    //第一次循环,是确定一个数依次和后面数的比较的数。
                                    for (int i = 0; i < arr.length -1 ; i++) {
                                       //这个是和第一个数的比较的数
                                        for (int j = i+1; j < arr.length; j++) {
                                          //定义一个临时的变量,用来交换变量
                                           int temp ;  
                                           if(arr[i]>arr[j]){
                                                temp =  arr[i];
                                                arr[i] = arr[j];
                                                arr[j] = temp;
                                           }
                                       }
                                    }
                            //打印最后的排序结果
                            System.out.println(Arrays.toString(arr));
                             }
                    }
    

    快速排序

    **排序思想:**冒泡排序的一种优化,挖坑填数。

    public class QuickSortUtils {
        /**
         * @param arr   要排序的数组
         * @param start 要排序的起始位
         * @param end   要排序的结束位置 数组长度-1
         */
        public static void quickSort(int[] arr, int start, int end) {
            if (start < end) {
                //找出中间索引
                int index = getIndex(arr, start, end);
                //分成左右两半,对左右凉拌进行递归调用
                quickSort(arr, start, index - 1);//递归排序左半部分
                //递归排序右半部分
                quickSort(arr, index + 1, end);
            }
        }
    
        /**
         * @param arr   要排序的数组
         * @param start 开始位置
         * @param end   结束位置
         * @return 返回的是分区的中间索引
         */
        //挖坑填数
        private static int getIndex(int[] arr, int start, int end) {
            int i = start;
            int j = end;
            //定义基准数
            int x = arr[i];
            while (i < j) {
                //1.先从后往前找
                while (i < j && arr[j] > x) {//
                    j--;
                }
                //挖坑填数
                if (i < j) {
                    arr[i] = arr[j];//填坑
                    i++;//顺遍让i 递增一下
                }
                //2.从前往后找
                while (i < j && arr[i] <= x) {
                    i++;
                }
                //挖坑填数
                if (i < j) {
                    arr[j] = arr[i];//填坑
                    j--;//顺遍让j 递减一下
                }
            }
            arr[i] = x;//把基准数填到最后一个坑里
            return i;
        }
    }
    

    直接插入排序

    **排序思想:**每次将一个待排序的记录,按其关键字大小插入到前面已经排好序的子序列中的适当位置,直到全部记录插入完成为止。
    在这里插入图片描述

    展开全文
  • 实现数组排序的几种方法

    千次阅读 2019-05-16 19:19:06
    冒泡排序 这里介绍两种思路实现冒泡排序,最终的结果是实现从小到大的排序。 第一种是每相邻的两个元素进行比较,如果第一个元素大于第二个元素,则交换这两个元素的位置。如此两两比较然后交换,一轮下来,最大的...

    冒泡排序

    这里先介绍一下冒泡排序。

    1. 其原理就是相邻的两个元素进行比较,如果第一个元素大于第二个元素,则交换这两个元素的位置。如此两两比较然后交换,一轮下来,最大的元素会跑到最后的位置去。然后进行下一轮比较,最终就实现了排序。代码实现如下:
    public static void main(String[] args) {
            int[] arr = new int[]{1, 8, 3, 2, 9, 7, 7, 25, 16};
            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]) {
                        int temp = arr[j + 1];
                        arr[j + 1] = arr[j];
                        arr[j] = temp;
                    }
                }
            }
    
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + ", ");
            }
        }
    

    附上打印结果:

    在这里插入图片描述

    然后说说冒泡排序的改进版:如果在排序的时候,比较一趟就实现了全部排序呢,那么后面的排序还有必要进行吗?当然是no,所以可以怎么做呢,我们可以定义一个布尔类型的flag,每趟比较过后,查看是否完成了所有排序,如果完成了就直接结束。具体代码如下:

    public static void arraySort(int[] a) {
            boolean flag;
            for (int i = 0; i < a.length - 1; i++) {  //此处表示比较躺数
                flag= false;
                for (int j = 0; j < a.length - 1 - i; j++) {
                    if (a[j] > a[j + 1]) {
                        int temp = a[j + 1];
                        a[j + 1] = a[j];
                        a[j] = temp;
                        flag= true;
                    }
                }
                if (!flag) return;
            }
        }
    

    选择排序

    1. 第二种是第一个元素与其他所有元素进行比较,如果第一个元素大于其他元素,则交换位置。如此一轮下来,可以比较出最小的元素,并将其交换到第一个位置。如此循环往复,最终便可以实现排序。其实这种排序方法叫选择排序,代码如下:
    public static void main(String[] args) {
            int[] arr = new int[]{1, 8, 3, 2, 9, 7, 7, 25, 16};
           for (int i = 0; i < arr.length - 1; i++) {
                for (int j = i + 1; j < arr.length; j++) {
                    if (arr[i] > arr[j]) {
                        int temp = arr[j];
                        arr[j] = arr[i];
                        arr[i] = temp;
                    }
                }
            }
    
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + ", ");
            }
        }
    

    打印结果和上图是一样的。

    快速排序

    1. 快速排序是冒泡排序的改进版,速度最快,但是相对没那么稳定。具体实现如下:
     public static void quickSort(int[] a, int left, int right) {
            if (left > right) {
                return;
            }
            int i, j, temp;
            i = left;
            j = right;
            temp = a[left];     //temp为基准位
    
            while (i < j) {
                //先从右往左遍历
                //遍历的顺序取决于基准位的选取位置,要从基准位的对面开始遍历
                while(i < j && a[j] >= temp) {
                    j--;
                }
                //然后从左往右遍历
                while (i < j && a[i] <= temp) {
                    i++;
                }
                //交换位置
                if (i < j) {
                    int s = a[i];
                    a[i] = a[j];
                    a[j] = s;
                }
            }
    
            //将基准位与i和j相等位置的数字交换
            a[left] = a[i];
            a[i] = temp;
            //递归调用左边部分数组
            quickSort(a, left, i - 1);
            //递归调用右边部分数组
            quickSort(a, j + 1, right);
        }
    

    更加详细介绍请参考这里

    更新于2018.11.30

    展开全文
  • 数组的五种排序方式

    2019-03-29 22:52:22
    数组的五种排序方式 排序是对数组施加的最常用的算法,所谓排序,是指将数组元素按照从小到大或从大到小的顺序重新排列;那么对于元素较多的数组排序算法的优劣至关重要; 一般情况下,通过排序过程中数组元素的...

    数组的五种排序方式

    排序是对数组施加的最常用的算法,所谓排序,是指将数组元素按照从小到大或从大到小的顺序重新排列;那么对于元素较多的数组,排序算法的优劣至关重要; 一般情况下,通过排序过程中数组元素的交换次数来衡量排序算法的优劣;
    而常用的排序算法有插入排序、冒泡排序、选择排序和java系统排序。

    1.选择排序

     选择排序的原理如下:
    

    • 将数组中每个元素与第一个元素比较,如果这个元素小于第一个元素, 则交换这两个元素
    • 循环第 1 条规则,找出最小元素,放于第 1 个位置
    • 经过 n-1 轮比较完成排序

    简单而言,每轮都找到最小的放到前面。举例:{8 , 2 , 3 , 7 , 1}的排序过程如下所示:
    

    数组: ary={8 , 2 , 3 , 7 , 1}
    第 1 轮: ary={1 | 8 , 3 , 7 , 2}
    第 2 轮: ary={1 , 2 | 8 , 7 , 3}
    第 3 轮: ary={1 , 2 , 3 | 8 , 7}
    第 4 轮: ary={1 , 2 , 3 , 7 | 8}
    第 5 轮: ary={1 , 2 , 3 , 7 | 8}
    调用选择排序的代码如下:
    在这里插入图片描述

    2.冒泡排序原理

     冒泡排序就是比较相邻的元素,将小的放到前面
    

    冒泡排序举例:{8 , 2 , 3 , 7 , 1}的排序过程如下所示:
    ary={8,2,3,7,1}
    ary={2,8,3,7,1}
    ary={2,3,8,7,1}
    ary={2,3,7,8,1}
    ary={2,3,7,1|8}
    ary={2,3,7,1|8}
    ary={2,3,7,1|8}
    ary={2,3,1|7,8}
    ary={2,3,1|7,8}
    ary={2,1|3,7,8}
    ary={1,2,3,7,8}

         调用冒泡排序的代码如下:
    

    在这里插入图片描述如果对排序的执行过程还有疑惑,可以使用输出语句观察执行结果,在写程序的过程中,程序员常常会使用输出语句中进行调试,如图所示:
    在这里插入图片描述

    3. 插入排序

     插入排序原理:
    

    • 将数组分为两部分, 将后部分的第一个逐一与前部分每一个元素比较,在合理位置插入
    • 插入排序算法效率要高于选择排序和冒泡排序

    插入排序举例:
    

    {8 , 2 , 3 , 7 , 1}的排序过程如下所示:
    第 1 步,假设第一个元素是已排序的 {8|2,3,7,1}
    第 2 步,用 2 和"|“之前的所有元素比较,并插入 {8|2,3,7,1}
    取出 2(temp=2)
    temp 和 8 比,比 8 小,将 2 的位置赋值为大数(ary[1]=8) {8|8,3,7,1}
    因为已到边界,直接赋值(ary[0]=2) {2,8|3,7,1}
    2 和 8 排序完成
    第 3 步,用 3 和”|“之前的所有元素比较,并插入 {2,8|3,7,1}
    取出 3(temp=3)
    temp 和 8 比,比 8 小,3 的位置赋值给大数(ary[2]=8) {2,8|8,7,1}
    temp 和 2 比,比 2 大,插入 2 后面 (ary[1]=3) {2,3,8|7,1}
    3、2、8 排序完成
    第 4 步,用 7 和”|“之前的所以元素比较,并插入 {2,3,8|7,1}
    取出 7(temp=7)
    temp 和 8 比,比 8 小,7 的位置赋值给大数(ary[3]=8) {2,3,8|8,1}
    temp 和 3 比,比 3 大,插入 3 后面(ary[2]=7) {2,3,7,8|1}
    7、2、3、8 排序完成
    第 5 步,用 1 和”|"之前的所以元素比较,幵插入 {2,3,7,8|1}
    取出 1(temp=1)
    temp 和 8 比,比 8 小,1 的位置赋值给大数 8 {2,3,7,8|8}
    temp 和 7 比,比 7 小,8 的位置赋值给大数 7 {2,3,7,7|8}
    temp 和 3 比,比 3 小,7 的位置赋值给大数 3 {2,3,3,7|8}
    temp 和 2 比,比 2 小,3 的位置赋值给大数 2 {2,2,3,7|8}
    到边界,赋值(ary[0]=1) {1,2,3,7,8|} 1、2、3、7、8 排序完成
    调用插入排序的代码如下:
    在这里插入图片描述

    4.java系统排序

     JDK 提供的排序方法 Arrays.sort(ary)的效率要比我们之前写的选择排序、冒泡排序等效率高。 因为插入排序算法效率要高于选择排序和冒
     泡排序 ,所以我们比较 一下Arrays.sort(ary)和插入排序的效率,如图所示:
    

    在这里插入图片描述
    运行结果:
    在这里插入图片描述
    • 运行结果为 0 表示不到 1 毫秒内就完成了排序
    • 不要试图在控制台输出数组元素,控制台打印输出不全

    在这些排序方法中, 最为方便快捷的就是我们的java系统排序,简单快捷实用,所以希望看到这篇文章的你好好的学习并且掌握到java系统排序,这可以节约你大量的时间来做其他的事情。与君共勉之。

    展开全文
  • 数组的7种排序汇总

    万次阅读 2019-03-01 11:09:04
    数组的7种排序汇总,代码很全思想很强大

    实际开发中不是每个都用,只是一种思想呈现。

    1、桶排序(桶中出现的数组元素都做个标记1,然后将桶数组中有1标记的元素依次打印)

    //简单, 但是不用,浪费内存
    var arr2=[];
    for(var i=0;i<arr.length;i++){
        var key=arr[i];
        arr2[key]=1;
    }
    for(var j in arr2){
        console.log(j);
    }

    2、冒泡排序(每一趟找出最大的)

    //性能一般
    var arr=[1,5,7,9,16,2,4];
    //冒泡排序,每一趟找出最大的,总共比较次数为arr.length-1次,每次的比较次数为arr.length-1次,依次递减
    var temp;
    for(var i=0;i<arr.length-1;i++){
        for(var j=0;j<arr.length-1;j++){
            if(arr[j]>arr[j+1]){
                temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }

    3、选择排序(假定某个位置的值是最小值)

    //性能一般
    var arr=[1,23,5,8,11,78,45];
    var temp;
    for(var i=0;i<arr.length-1;i++){
        for(var j=i+1;j<arr.length;j++){
            if(arr[i]>arr[j]){
                temp=arr[i];
                arr[i]=arr[j];
                arr[j]=temp;
            }
        }
    }
    

    4、快速排序(一拆为二)

    function quickSort(arr){
        if(arr.length <= 1){
            return arr;
        }
        var left = [];
        var right = [];
        var midIndex = parseInt(arr.length / 2);
        var mid = arr[midIndex];
        for(var i = 0 ; i < arr.length ; i++){
            if(i == midIndex) continue;
            if( arr[i] < mid){
                left.push(arr[i])
            }else{
                right.push(arr[i]);
            }
        }
        return quickSort(left).concat([mid],quickSort(right));
    }
    
    [1,2].concat([3],[4,5]);   //[1, 2, 3, 4, 5]

    5、插入排序

    var arr=[45,1,32,21,56,87,43,12,34,45];
        for(var i=0;i<arr.length;i++){
        var n=i;
        while(arr[n]>arr[n+1] && n>=0){
     	    var temp=arr[n];
    	    arr[n]=arr[n+1];
     	    arr[n+1]=temp;
    	    n--;
        }
    }

    6、希尔排序(性能最好的排序)

    function xier(arr){
        var interval = parseInt(arr.length / 2);  //分组间隔设置
        while(interval > 0){
            for(var i = 0 ; i < arr.length ; i ++){
                var n = i;
                while(arr[n] < arr[n - interval] && n > 0){
                    var temp = arr[n];
                    arr[n] = arr[n - interval];
                    arr[n - interval] = temp;
                    n = n - interval;
                }
            }
            interval = parseInt(interval / 2);
        }
        return arr;
    }
    xier([12,9,38,44,7,98,35,59,49,88,38]);

    7、sort排序

    //一维数组排序
    var arr=[1,5,7,9,16,2,4];
    arr.sort(function(a,b){
        return b-a;  //降序排列,return a-b; —>升序排列
    })  //括号里不写回调函数,则默认按照字母逐位升序排列,结果为[1,16,2,4,5,7,9]
    //对象数组排序
    var arr = [
        {name:'syy',age:0},
        {name:'wxy',age:18},
        {name:'slj',age:8},
        {name:'wj',age:20}
    ];
    
    function compare(property){
        return function(a,b){
            var value1 = a[property];
            var value2 = b[property];
            return value1 - value2;//升序,降序为value2 - value1
        }
    }
    arr.sort(compare('age'))

     

    展开全文
  • 数组的四种排列方法

    万次阅读 2018-10-30 14:11:36
    冒泡排序:从数组中首元素开始和其他元素逐个比较,若其中一个元素比其小(或大),就交换首元素与其位置 int k[] = {3,4,5,1,0,2}; for(int i=0;i&lt;k.length-1;i++) { for(int j=i+1;j&lt;k....
  • C语言一维数组排序问题(一)

    千次阅读 2019-07-09 01:07:35
    1.起泡(冒泡)法排序 基本思路:每次将相邻两个数比较,将小的(大的)调到前边。如图: 第一趟后最大(最小)数 “沉底”,然后进行第二趟,第三趟。。。 如果有n个数,则要进行n-1趟比较,在第一趟中进行n-1...
  • 大数组的排序

    2020-01-20 12:54:07
    之前有一个同事问我,如何对一个非常大的数组进行排序,最开始的思路是:化整为零 合并排序。但实际上具体的一些细节还是有待商榷,因此 这里写一篇文章来具体来总结一下。 问题 假如一个数组中有1亿个数字,那么要对...
  • 4.数组排序

    2019-07-10 08:33:58
    一丶数组 1.定义:相同数据类型的多个数据组成的一个集合 2.语法: 方案一: 数据类型[] 标识符 = {1,2,3,4}; 方案二: 数据类型[] 标识符 = new 数据类型[数组长度]; 方案三: 数据类型[] 标识符 = new 数据类型[]{1,2,3...
  • C#各种数组排序方法介绍

    千次阅读 2020-04-21 21:03:25
    双层for循环,数组内部元素不断比较交换,最终排序。 时间复杂度为O(n²) private void bubbleSort(int[] array) { int median=0; for(int i=0;i<array.Length-1;i++) { for(int j=i+1;j<array....
  • java数组排序

    千次阅读 2019-05-15 21:00:57
    Java数组排序 开发工具与关键技术:myEclipse javaEE 作者:林国佳 撰写时间:20180515 选择排序: 就是第1与第2比,如果第1比第2大,位置互换, 互换后的第1与第3比,如果第1比第3大,位置互换, 一直到最后,...
  • 数组排序的六种方法

    2015-03-01 21:07:16
    int array[] = {5, ...1. 冒泡排序 原理: 比较相邻的元素。如果第一个比第二个大,就交换他们两个。对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。针对
  • JAVA数组中五种常见排序方法

    万次阅读 多人点赞 2019-10-13 10:52:59
    几种常用的JAVA数组排序方法的整合。 法一:Arrays.sort() Arrays.sort()排序方法在java中是最简单且最常用的排序方法 int []arr1= {45,34,59,55}; Arrays.sort(arr1);//调用方法排序即可 法二:冒泡排序 ...
  • JavaScript之ES6数组排序 高逼格!

    千次阅读 多人点赞 2020-01-17 14:17:04
    针对于前端开发者来讲、数组排序的应用场景其实并不多,大多数情况下都是后台数据排序之后再返回给前端。但是很多面试题中会经常遇到数组排序的问题,经典案例有冒泡排序、插入排序、选择排序等等... 逻辑性比较强硬...
  • php 多维数组按数组的某一字段排序 数组排序 如果你已经使用了一段时间PHP的话,那么,你应该已经对它的数组比较熟悉了——这种数据结构允许你在单个变量中存储多个值,并且可以把它们作为一个集合进行操作。 ...
  • 原生js数组排序

    千次阅读 2020-06-10 16:27:19
    原生js数组排序 js 排序 以正序为例(即由小到大) var arr = [0,2,1,4,3,9,6,5,7,8]; // 未排序的数组 var sortArr = null; // 排序后得到的数组 1 sort排序 sortArr = arr.sort(function (a,b) { return a - b ...
  • 我们现在已知有这样一个数组: ...首先先来数组排序的方法: 1.数组的sort排序方法: 注意点: 数组的sort方法会改变原有数组 array.sort((a, b) => a - b;) //升序 array.sort((a, b) => b - a;) //降...
  • Java二维数组排序

    千次阅读 2019-06-29 15:46:12
    Java二维数组排序
  • java数组排序的几种方法

    万次阅读 2018-06-22 09:07:05
    因为看书看到了java数组排序,所以将常用的几种排序方法写下来,仅供参考。(1)用sort排序(从小到大)int[] arr = {5,2,66,3,7};Arrays.sort(arr);//Arrays是util包for(int i : arr){ System.out.println(i);}(2)...
  • 数组排序——插入排序

    千次阅读 2018-04-18 08:38:27
    数组排序——插入排序1、数组排序之插入排序原理:将n个元素的数列分为已有序和无序两个部分,如插入排序过程示例下所示: {{a1},{a2,a3,a4,…,an}} {{a1⑴,a2⑴},{a3⑴,a4⑴ …,an⑴}} {{a1(n-1),a2(n-...
  • vue 数组排序、对象排序

    千次阅读 2019-01-17 11:06:48
    &lt;div class="sort"&gt; &...数组排序&lt;/h3&gt; &lt;div&gt;&lt;span&gt;排序后&lt;/span&gt;{{sortAry}}&lt;/div&gt; &lt
1 2 3 4 5 ... 20
收藏数 720,760
精华内容 288,304
关键字:

数组排序