精华内容
下载资源
问答
  • java排序

    2011-10-08 22:16:39
    java排序排序java排序排序java排序排序java排序排序
  • java排序方法 java排序方法 java排序方法 java排序方法
  • java 排序

    2012-12-26 11:50:00
    java 排序:插入排序、堆排序、二分法排序、归并排序、快速排序、希尔排序、选择排序
  • JAVA排序汇总JAVA排序汇总JAVA排序汇总
  • java 排序汇总 排序 算法 java 排序汇总 排序 算法
  • java排序算法

    2013-04-15 09:36:38
    java排序算法源码,有插入排序,选择排序,快速排序,shell排序
  • java 排序 算法

    2009-11-24 19:12:53
    Java 排序 快速排序,等Java 排序 快速排序,等
  • Java排序算法实现

    2018-03-06 19:52:59
    Java排序算法实现 Java排序算法实现 Java排序算法实现
  • 主要介绍了Java排序算法总结之归并排序,较为详细的分析了归并排序的原理与java实现技巧,需要的朋友可以参考下
  • 主要介绍了Java排序算法总结之冒泡排序,较为详细的分析了冒泡排序的原理与java实现技巧,需要的朋友可以参考下
  • java快速排序 归并排序 冒泡排序 选择排序
  • java排序之选择排序

    千次阅读 2018-10-19 11:38:04
    选择排序改进了冒泡排序,所改进的是排序时交换的次数,并没有改进比较的次数。在大批量数据排序的时候,选择排序中对于交换数据的时间和比较的时间来说,很显然,数据交换和移动的时间更为重要(一般来说,Java中...

          选择排序改进了冒泡排序,所改进的是排序时交换的次数,并没有改进比较的次数。在大批量数据排序的时候,选择排序中对于交换数据的时间和比较的时间来说,很显然,数据交换和移动的时间更为重要(一般来说,Java中不是这种情况,Java中只是改变了引用的位置,而实际对象的位置并未发生改变)

        用选择排序对篮球队员进行排序:

    进行选择排序就是把所有的队员扫描一遍,找到其中最低的队员,让他与最左边的队员(0号位置)进行交换(如果最左边的队员就是最低的,那么不进行交换)。这样最左边的队员就是有序的状态,不需要再次交换位置了。注意,这个算法中呢,有序的都排列在队伍的最左边,与冒泡排序相反(冒泡排序是从最右边)。再次扫描队列时,就是从1号位置开始,也是找到最矮的,与队列的1号位置进行交换,那么依次下去,一直持续到整个顺序排列完成。

    第一次扫描:

    第二次扫描:

    第三次扫描:

     依次如图所示。

    接下来上代码:

    public class selectSort {
        private long[] a;
        private int nElems ;
        public selectSort(int max) {
            a = new long[max];
            nElems = 0;
        }
        public void insert(long value) {
            a[nElems] = value;
            nElems++;
        }
        
        public void display() {
            for (int i = 0; i < nElems-1; i++) {
                System.out.println(a[i]+"");
            }
            System.out.println("");
        }
        
        public void swap(int one , int two) {
            long temp = a[one];
            a[one] = a[two];
            a[two] = temp;
        }
        
        public void selectSortApp() {
            int min ,in ,out ;
            for ( out = 0; out < nElems-1; out++) {
                min = out ;
                for ( in = out+1; in < nElems; in++) {
                    if(a[in]<a[min]){
                        min = in;
                    }
                }
                swap(out, min);
            }
        }
    }

    out:用来记录外层循环,从数组开头0开始,依次增长。

    in:用来记录内层循环,找到每一轮的最矮队员,并将他与这一轮起始的队员进行交换。

    min:用来记录当前最矮的队员。

    选择排序的效率:选择排序与冒泡排序进行了同样次数的比较,N*(N-1)/2,但是一列数组如果有10个数据项,只需要少于10次的比较就可以了。如果数据量N约大,那么选择排序就会比冒泡排序节省很多时间(在数据交换位置上节省),数据量很小的情况下,两者相当。

     

    展开全文
  • 软件工程、快速排序法。绝顶的好东西。快速排序.Java快速排序.Java快速排序.Java
  • Java排序算法

    千次阅读 2017-11-23 12:28:55
    Java排序算法正在Java学习之排序算法,思路来源:http://blog.csdn.net/chao360559040/article/details/5973716一、直接插入排序 每次执行,把后面的数插入到前面已经排序好的数组中,直到最后一个完成。public ...

    Java排序算法

    一、直接插入排序

    Java学习之直接插入排序,思路源于:http://blog.csdn.net/chao360559040/article/details/5973716

    原理:每次执行,把后面的数插入到前面已经排序好的数组中,直到最后一个完成。

    public class DirectinsertSort {

    public void directinsertSort(int arr[]) {
        int j,temp;
        for(int i = 1; i < arr.length; i ++) {
            temp = arr[i];
            for(j =i-1; j >= 0; j --) {
                if(temp >= arr[j]) {
                    break;
                }
                arr[j+1] = arr[j];
            }
            arr[j+1] = temp;
        }
    }
    
    public static void main(String[] args) {
        int arr[] = {11,23,14,88,99,77,55,67,66};
        new DirectinsertSort().directinsertSort(arr);
        for(int a : arr) {
            System.out.print(a + " ");
        }
    }
    

    }
    运行结果:11 14 23 55 66 67 77 88 99

    代码编写与原文相差之处为if条件判断条件为temp>=arr[j],在此处改变的原因是想要让其更改为从小至大排序。

    思路如下:

    1. 传入directinsert_sort(int arr[])的为一个数组arr[],而数组通过数组名称定位到数组内存所在地址,所以不需要返回值即可实现数组的改变。
    2. 在directinsert_sort(int arr[])中首先定义一个临时变量temp用于存储将要插入数组的值。
    3. 第一层i的for循环从arr[1]到arr[arr.length]循环遍历整个数组,在其中设定temp = arr[i],用于存储第一个要插入的数值,i=1时第一次遍历arr[1]之前的数组已排序好(只有一个arr[0],想不排好也难)。
    4. 第二层j的for循环中从i-1到0遍历整个数组,判断如果要插入的值temp >= arr[j]成立时,终止第二层循环,将temp值插入原本排好序的数组最后(i=1时,即arr[i] = temp,arr[0]已排好序);如果判断条件不成立及将原本排序好的数组的最后一个数后移后一位,继续第二层循环,知道判断成立,将temp插入数组正确位置。

    二、快速排序

    Java学习之快速排序,思路源于:https://www.cnblogs.com/hjy9420/p/5032309.html

    原理:选择一个关键值作为基准值。比基准值小的都在左边序列(一般是无序的),比基准值大的都在右边(一般是无序的)。

    public class QuitSort {

    public void quitSort(int arr[], int low, int high) {
        int start = low;
        int end = high;
        int key = arr[low];
    
        while(start < end) {
            while(end > start && key <= arr[end]) {
                end --;
            }
            if(key >= arr[end]) {
                int temp = arr[end];
                arr[end] = arr[start];
                arr[start] = temp;
            }
    
            while(start < end && arr[start] <= key) {
                start ++;
            }
            if(arr[start] >= key) {
                int temp = arr[start];
                arr[start] = arr[end];
                arr[end] = temp;
            }
        }
    
        if(start > low) {
            quit_sort(arr, low, start-1);
        }
        if(end < high) {
            quit_sort(arr, end+1, high);
        }
    }
    
    public static void main(String[] args) {
        int arr[] = {12,20,5,16,15,1,30,45,23,9};
        int start = 0;
        int end = arr.length - 1;
        new QuitSort().quitSort(arr, start, end);
        for(int a : arr){
             System.out.print(a + " ");
         }
    }
    

    }
    运行结果:1 5 9 12 15 16 20 23 30 45

    思路如下:

    1. 传入quit_sort(int arr[], int low, int high)的为数组arr[]、数组最初的下标起点和下标终点,而数组通过数组名称定位到数组内存所在地址,所以不需要返回值即可实现数组的改变。
    2. 在quit_sort(int arr[], int low, int high)中首先定义三个变量start、end、key用于标识数组下标游走的起始位置、数组下标游走的最终位置、基准值。
    3. 比较start和end,start >= end时表明基于基准值key左右两边已摆好(左边值比基准值key小,右边值比基准值大)。
    4. start < end则进入循环,因为选定的基准值key为原数组第一个值,所以先对原数组进行从右至左的遍历,当遇到比基准值key大或等时将标识end减少1再进行判断,直到从右至左遍历原数组中值小于基准值key时退出循环之后将此位置的值与数组之前的标识start的值arr[start]替换位置;然后再进行从左至右的遍历,当遇到比基准值key小或等时将标识start增加1再进行判断,直到从左至右遍历原数组中值大于基准值key时退出循环之后将此位置的值与数组之前的标识end的值arr[end]替换位置。
    5. 最后通过递归将当前基准值两边的杂乱数据排序,直到标识start、end回归最初的初始标记也就是查询数组的下标起点low和下标终点high。

      三、冒泡排序

    Java学习之冒泡排序,思路源于:http://blog.csdn.net/pzhtpf/article/details/7560294

    原理:在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒。

    public class BubbleSort {

    public void bubbleSort(int[] arr) {
        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];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
    
    public static void main(String[] args) {
        int arr[] = {11,23,14,88,99,77,55,67,66,1,30,45,23,9};
        new BubbleSort().bubbleSort(arr);
        for(int a : arr) {
            System.out.print(a + " ");
        }
    }
    

    }
    运行结果:1 9 11 14 23 23 30 45 55 66 67 77 88 99

    思路如下:

    外循环用于控制循环次数,内循环用于将数组中较大值后移,通过j < arr.length - 1 - i能将判断好的较大值排除出要判断的数组,最终,将数组中的值完全排列。

    以上为个人思路,如有不对,希望大家帮忙斧正,谢谢。

    总结:软件开发实践带动理解。

    展开全文
  • java排序.txt

    2014-04-30 22:31:17
    java排序.txt
  • java排序签名

    2018-11-06 14:44:43
    实现当前主流签名机制。 对请求参数进行排序 并添加协议key值 进行Md5加密
  • java排序代码大全

    2008-12-28 04:10:10
    java排序 java 排序 排序大全 算法 java算法
  • 主要介绍了Java排序算法之归并排序简单实现,具有一定借鉴价值,需要的朋友可以参考下。
  • java冒泡排序

    2011-09-29 00:13:28
    java冒泡排序 java冒泡排序 java冒泡排序
  • 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基础(冒泡排序)

    万次阅读 多人点赞 2019-05-17 16:54:30
    冒泡排序简介 比较相邻的元素。如果第一个比第二个大,就交换他们两个。 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。 针对所有的元素重复以上的...

    一.冒泡排序简介(从小到大排序)

                比较相邻的元素。如果第一个比第二个大,就交换他们两个。

                对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。

                针对所有的元素重复以上的步骤,除了最后一个,即需要进行length-1次。

                第一次是对n个数进行n-1次比较,进行到最后第n个的一个是最大的;

                第二次是对n-1个数进行n-2次比较,进行到最后第n-1个的一个是最大的;

                ......

                持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

                动态图:

    二.代码案例

    package day0515;
    public class demo_sort {
        public static void main(String[] args) {
            //冒泡排序算法
            int[] numbers=new int[]{1,5,8,2,3,9,4};
            //需进行length-1次冒泡
            for(int i=0;i<numbers.length-1;i++)
            {
                for(int j=0;j<numbers.length-1-i;j++)
                {
                    if(numbers[j]>numbers[j+1])
                    {
                        int temp=numbers[j];
                        numbers[j]=numbers[j+1];
                        numbers[j+1]=temp;
                    }
                }
            }
            System.out.println("从小到大排序后的结果是:");
            for(int i=0;i<numbers.length;i++)
                System.out.print(numbers[i]+" ");
        }
    }
    

    三.debug命令调试

    •     在需要断点的行数前面进行点击(打断点)

    •     右键单击Debug模式运行

    •     F8快捷键依次执行代码

     

    展开全文
  • Java 排序 Lambda

    千次阅读 2017-06-16 14:20:12
    利用Lambda传入排序行为,代码如下: import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.List; public class Sort { public...
  • java基数排序

    2014-09-18 21:07:28
    java排序算法之基数排序。其中test.java为测试文件。
  • java数组排序

    2017-09-04 11:39:37
    java数组排序的思想,过程和代码实现。多种数组排序的方法,主要有冒泡排序,堆排序,插入排序, 归并操作(merge), 归并操作(merge),选择排序,希尔排序
  • 常见几种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++) { //挖出一个要用来插入...
  • Java排序方法详解大全

    2011-02-28 09:26:12
    Java排序方法详解大全 Java排序 快速排序 冒泡排序
  • 每位数去计数排序 建议先看计数排序 public class RadixSort { public static void main(String[] args) { int[] arr = {123, 15, 99, 85, 8888, 0, 0, 99}; int n = arr.length; radixsort(arr, n); print...
  • Java三种排序 Java三种排序 Java三种排序

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 746,072
精华内容 298,428
关键字:

当用java排序时

java 订阅