1. package com.softeem.jbs.lesson4;
  2.  
  3. import java.util.Random;
  4.  
  5. /**
  6.  
  7.  * 排序测试类
  8.  
  9.  *
  10.  
  11.  * 排序算法的分类如下：
  12.  
  13.  * 1.插入排序（直接插入排序、折半插入排序、希尔排序）；
  14.  
  15.  * 2.交换排序（冒泡泡排序、快速排序）；
  16.  
  17.  * 3.选择排序（直接选择排序、堆排序）；
  18.  
  19.  * 4.归并排序；
  20.  
  21.  * 5.基数排序。
  22.  
  23.  *
  24.  
  25.  * 关于排序方法的选择：
  26.  
  27.  * (1)若n较小(如n≤50)，可采用直接插入或直接选择排序。
  28.  
  29.  * 　当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插人，应选直接选择排序为宜。
  30.  
  31.  * (2)若文件初始状态基本有序(指正序)，则应选用直接插人、冒泡或随机的快速排序为宜；
  32.  
  33.  * (3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。
  34.  
  35.  *
  36.  
  37.  */
  38.  
  39. public class SortTest {
  40.  
  41.        /**
  42.  
  43.         * 初始化测试数组的方法
  44.  
  45.         * @return 一个初始化好的数组
  46.  
  47.         */
  48.  
  49.        public int[] createArray() {
  50.  
  51.               Random random = new Random();
  52.  
  53.               int[] array = new int[];
  54.  
  55.               for (int i = ; i < ; i++) {
  56.  
  57.                      array[i] = random.nextInt() - random.nextInt();//生成两个随机数相减，保证生成的数中有负数
  58.  
  59.               }
  60.  
  61.               System.out.println("==========原始序列==========");
  62.  
  63.               printArray(array);
  64.  
  65.               return array;
  66.  
  67.        }
  68.  
  69.        /**
  70.  
  71.         * 打印数组中的元素到控制台
  72.  
  73.         * @param source
  74.  
  75.         */
  76.  
  77.        public void printArray(int[] data) {
  78.  
  79.               for (int i : data) {
  80.  
  81.                      System.out.print(i + " ");
  82.  
  83.               }
  84.  
  85.               System.out.println();
  86.  
  87.        }
  88.  
  89.        /**
  90.  
  91.         * 交换数组中指定的两元素的位置
  92.  
  93.         * @param data
  94.  
  95.         * @param x
  96.  
  97.         * @param y
  98.  
  99.         */
  100.  
  101.        private void swap(int[] data, int x, int y) {
  102.  
  103.               int temp = data[x];
  104.  
  105.               data[x] = data[y];
  106.  
  107.               data[y] = temp;
  108.  
  109.        }
  110.  
  111.        /**
  112.  
  113.         * 冒泡排序----交换排序的一种
  114.  
  115.         * 方法：相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），下一次循环是将其他的数进行类似操作。
  116.  
  117.         * 性能：比较次数O(n^2),n^2/2；交换次数O(n^2),n^2/4
  118.  
  119.         *
  120.  
  121.         * @param data 要排序的数组
  122.  
  123.         * @param sortType 排序类型
  124.  
  125.         * @return
  126.  
  127.         */
  128.  
  129.        public void bubbleSort(int[] data, String sortType) {
  130.  
  131.               if (sortType.equals("asc")) { //正排序，从小排到大
  132.  
  133.                      //比较的轮数
  134.  
  135.                      for (int i = ; i < data.length; i++) {
  136.  
  137.                             //将相邻两个数进行比较，较大的数往后冒泡
  138.  
  139.                             for (int j = ; j < data.length - i; j++) {
  140.  
  141.                                    if (data[j] > data[j + ]) {
  142.  
  143.                                           //交换相邻两个数
  144.  
  145.                                           swap(data, j, j + );
  146.  
  147.                                    }
  148.  
  149.                             }
  150.  
  151.                      }
  152.  
  153.               } else if (sortType.equals("desc")) { //倒排序，从大排到小
  154.  
  155.                      //比较的轮数
  156.  
  157.                      for (int i = ; i < data.length; i++) {
  158.  
  159.                             //将相邻两个数进行比较，较大的数往后冒泡
  160.  
  161.                             for (int j = ; j < data.length - i; j++) {
  162.  
  163.                                    if (data[j] < data[j + ]) {
  164.  
  165.                                           //交换相邻两个数
  166.  
  167.                                           swap(data, j, j + );
  168.  
  169.                                    }
  170.  
  171.                             }
  172.  
  173.                      }
  174.  
  175.               } else {
  176.  
  177.                      System.out.println("您输入的排序类型错误！");
  178.  
  179.               }
  180.  
  181.               printArray(data);//输出冒泡排序后的数组值
  182.  
  183.        }
  184.  
  185.        /**
  186.  
  187.         * 直接选择排序法----选择排序的一种
  188.  
  189.         * 方法：每一趟从待排序的数据元素中选出最小（或最大）的一个元素， 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
  190.  
  191.         * 性能：比较次数O(n^2),n^2/2
  192.  
  193.         *       交换次数O(n),n
  194.  
  195.         *       交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CUP时间多，所以选择排序比冒泡排序快。
  196.  
  197.         *       但是N比较大时，比较所需的CPU时间占主要地位，所以这时的性能和冒泡排序差不太多，但毫无疑问肯定要快些。
  198.  
  199.         *
  200.  
  201.         * @param data 要排序的数组
  202.  
  203.         * @param sortType 排序类型
  204.  
  205.         * @return
  206.  
  207.         */
  208.  
  209.        public void selectSort(int[] data, String sortType) {
  210.  
  211.               if (sortType.equals("asc")) { //正排序，从小排到大
  212.  
  213.                      int index;
  214.  
  215.                      for (int i = ; i < data.length; i++) {
  216.  
  217.                             index = ;
  218.  
  219.                             for (int j = ; j <= data.length - i; j++) {
  220.  
  221.                                    if (data[j] > data[index]) {
  222.  
  223.                                           index = j;
  224.  
  225.                                    }
  226.  
  227.                             }
  228.  
  229.                             //交换在位置data.length-i和index(最大值)两个数
  230.  
  231.                             swap(data, data.length - i, index);
  232.  
  233.                      }
  234.  
  235.               } else if (sortType.equals("desc")) { //倒排序，从大排到小
  236.  
  237.                      int index;
  238.  
  239.                      for (int i = ; i < data.length; i++) {
  240.  
  241.                             index = ;
  242.  
  243.                             for (int j = ; j <= data.length - i; j++) {
  244.  
  245.                                    if (data[j] < data[index]) {
  246.  
  247.                                           index = j;
  248.  
  249.                                    }
  250.  
  251.                             }
  252.  
  253.                             //交换在位置data.length-i和index(最大值)两个数
  254.  
  255.                             swap(data, data.length - i, index);
  256.  
  257.                      }
  258.  
  259.               } else {
  260.  
  261.                      System.out.println("您输入的排序类型错误！");
  262.  
  263.               }
  264.  
  265.               printArray(data);//输出直接选择排序后的数组值
  266.  
  267.        }
  268.  
  269.        /**
  270.  
  271.         * 插入排序
  272.  
  273.         * 方法：将一个记录插入到已排好序的有序表（有可能是空表）中,从而得到一个新的记录数增1的有序表。
  274.  
  275.         * 性能：比较次数O(n^2),n^2/4
  276.  
  277.         *       复制次数O(n),n^2/4
  278.  
  279.         *       比较次数是前两者的一般，而复制所需的CPU时间较交换少，所以性能上比冒泡排序提高一倍多，而比选择排序也要快。
  280.  
  281.         *
  282.  
  283.         * @param data 要排序的数组
  284.  
  285.         * @param sortType 排序类型
  286.  
  287.         */
  288.  
  289.        public void insertSort(int[] data, String sortType) {
  290.  
  291.               if (sortType.equals("asc")) { //正排序，从小排到大
  292.  
  293.                      //比较的轮数
  294.  
  295.                      for (int i = ; i < data.length; i++) {
  296.  
  297.                             //保证前i+1个数排好序
  298.  
  299.                             for (int j = ; j < i; j++) {
  300.  
  301.                                    if (data[j] > data[i]) {
  302.  
  303.                                           //交换在位置j和i两个数
  304.  
  305.                                           swap(data, i, j);
  306.  
  307.                                    }
  308.  
  309.                             }
  310.  
  311.                      }
  312.  
  313.               } else if (sortType.equals("desc")) { //倒排序，从大排到小
  314.  
  315.                      //比较的轮数
  316.  
  317.                      for (int i = ; i < data.length; i++) {
  318.  
  319.                             //保证前i+1个数排好序
  320.  
  321.                             for (int j = ; j < i; j++) {
  322.  
  323.                                    if (data[j] < data[i]) {
  324.  
  325.                                           //交换在位置j和i两个数
  326.  
  327.                                           swap(data, i, j);
  328.  
  329.                                    }
  330.  
  331.                             }
  332.  
  333.                      }
  334.  
  335.               } else {
  336.  
  337.                      System.out.println("您输入的排序类型错误！");
  338.  
  339.               }
  340.  
  341.               printArray(data);//输出插入排序后的数组值
  342.  
  343.        }
  344.  
  345.        /**
  346.  
  347.         * 反转数组的方法
  348.  
  349.         * @param data 源数组
  350.  
  351.         */
  352.  
  353.        public void reverse(int[] data) {
  354.  
  355.               int length = data.length;
  356.  
  357.               int temp = ;//临时变量
  358.  
  359.               for (int i = ; i < length / ; i++) {
  360.  
  361.                      temp = data[i];
  362.  
  363.                      data[i] = data[length -  - i];
  364.  
  365.                      data[length -  - i] = temp;
  366.  
  367.               }
  368.  
  369.               printArray(data);//输出到转后数组的值
  370.  
  371.        }
  372.  
  373.        /**
  374.  
  375.         * 快速排序
  376.  
  377.         * 快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。
  378.  
  379.         * 步骤为：
  380.  
  381.         * 1. 从数列中挑出一个元素，称为 "基准"（pivot），
  382.  
  383.         * 2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分割之后，该基准是它的最后位置。这个称为分割（partition）操作。
  384.  
  385.         * 3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
  386.  
  387.         * 递回的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递回下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
  388.  
  389.         * @param data 待排序的数组
  390.  
  391.         * @param low
  392.  
  393.         * @param high
  394.  
  395.         * @see SortTest#qsort(int[], int, int)
  396.  
  397.         * @see SortTest#qsort_desc(int[], int, int)
  398.  
  399.         */
  400.  
  401.        public void quickSort(int[] data, String sortType) {
  402.  
  403.               if (sortType.equals("asc")) { //正排序，从小排到大
  404.  
  405.                      qsort_asc(data, , data.length - );
  406.  
  407.               } else if (sortType.equals("desc")) { //倒排序，从大排到小
  408.  
  409.                      qsort_desc(data, , data.length - );
  410.  
  411.               } else {
  412.  
  413.                      System.out.println("您输入的排序类型错误！");
  414.  
  415.               }
  416.  
  417.        }
  418.  
  419.        /**
  420.  
  421.         * 快速排序的具体实现，排正序
  422.  
  423.         * @param data
  424.  
  425.         * @param low
  426.  
  427.         * @param high
  428.  
  429.         */
  430.  
  431.        private void qsort_asc(int data[], int low, int high) {
  432.  
  433.               int i, j, x;
  434.  
  435.               if (low < high) { //这个条件用来结束递归
  436.  
  437.                      i = low;
  438.  
  439.                      j = high;
  440.  
  441.                      x = data[i];
  442.  
  443.                      while (i < j) {
  444.  
  445.                             while (i < j && data[j] > x) {
  446.  
  447.                                    j--; //从右向左找第一个小于x的数
  448.  
  449.                             }
  450.  
  451.                             if (i < j) {
  452.  
  453.                                    data[i] = data[j];
  454.  
  455.                                    i++;
  456.  
  457.                             }
  458.  
  459.                             while (i < j && data[i] < x) {
  460.  
  461.                                    i++; //从左向右找第一个大于x的数
  462.  
  463.                             }
  464.  
  465.                             if (i < j) {
  466.  
  467.                                    data[j] = data[i];
  468.  
  469.                                    j--;
  470.  
  471.                             }
  472.  
  473.                      }
  474.  
  475.                      data[i] = x;
  476.  
  477.                      qsort_asc(data, low, i - );
  478.  
  479.                      qsort_asc(data, i + , high);
  480.  
  481.               }
  482.  
  483.        }
  484.  
  485.        /**
  486.  
  487.         * 快速排序的具体实现，排倒序
  488.  
  489.         * @param data
  490.  
  491.         * @param low
  492.  
  493.         * @param high
  494.  
  495.         */
  496.  
  497.        private void qsort_desc(int data[], int low, int high) {
  498.  
  499.               int i, j, x;
  500.  
  501.               if (low < high) { //这个条件用来结束递归
  502.  
  503.                      i = low;
  504.  
  505.                      j = high;
  506.  
  507.                      x = data[i];
  508.  
  509.                      while (i < j) {
  510.  
  511.                             while (i < j && data[j] < x) {
  512.  
  513.                                    j--; //从右向左找第一个小于x的数
  514.  
  515.                             }
  516.  
  517.                             if (i < j) {
  518.  
  519.                                    data[i] = data[j];
  520.  
  521.                                    i++;
  522.  
  523.                             }
  524.  
  525.                             while (i < j && data[i] > x) {
  526.  
  527.                                    i++; //从左向右找第一个大于x的数
  528.  
  529.                             }
  530.  
  531.                             if (i < j) {
  532.  
  533.                                    data[j] = data[i];
  534.  
  535.                                    j--;
  536.  
  537.                             }
  538.  
  539.                      }
  540.  
  541.                      data[i] = x;
  542.  
  543.                      qsort_desc(data, low, i - );
  544.  
  545.                      qsort_desc(data, i + , high);
  546.  
  547.               }
  548.  
  549.        }
  550.  
  551.        /**
  552.  
  553.         *二分查找特定整数在整型数组中的位置(递归)
  554.  
  555.         *查找线性表必须是有序列表
  556.  
  557.         *@paramdataset
  558.  
  559.         *@paramdata
  560.  
  561.         *@parambeginIndex
  562.  
  563.         *@paramendIndex
  564.  
  565.         *@returnindex
  566.  
  567.         */
  568.  
  569.        public int binarySearch(int[] dataset, int data, int beginIndex,
  570.  
  571.                      int endIndex) {
  572.  
  573.               int midIndex = (beginIndex + endIndex) >>> ; //相当于mid = (low + high) / 2，但是效率会高些
  574.  
  575.               if (data < dataset[beginIndex] || data > dataset[endIndex]
  576.  
  577.                             || beginIndex > endIndex)
  578.  
  579.                      return -;
  580.  
  581.               if (data < dataset[midIndex]) {
  582.  
  583.                      return binarySearch(dataset, data, beginIndex, midIndex - );
  584.  
  585.               } else if (data > dataset[midIndex]) {
  586.  
  587.                      return binarySearch(dataset, data, midIndex + , endIndex);
  588.  
  589.               } else {
  590.  
  591.                      return midIndex;
  592.  
  593.               }
  594.  
  595.        }
  596.  
  597.        /**
  598.  
  599.         *二分查找特定整数在整型数组中的位置(非递归)
  600.  
  601.         *查找线性表必须是有序列表
  602.  
  603.         *@paramdataset
  604.  
  605.         *@paramdata
  606.  
  607.         *@returnindex
  608.  
  609.         */
  610.  
  611.        public int binarySearch(int[] dataset, int data) {
  612.  
  613.               int beginIndex = ;
  614.  
  615.               int endIndex = dataset.length - ;
  616.  
  617.               int midIndex = -;
  618.  
  619.               if (data < dataset[beginIndex] || data > dataset[endIndex]
  620.  
  621.                             || beginIndex > endIndex)
  622.  
  623.                      return -;
  624.  
  625.               while (beginIndex <= endIndex) {
  626.  
  627.                      midIndex = (beginIndex + endIndex) >>> ; //相当于midIndex = (beginIndex + endIndex) / 2，但是效率会高些
  628.  
  629.                      if (data < dataset[midIndex]) {
  630.  
  631.                             endIndex = midIndex - ;
  632.  
  633.                      } else if (data > dataset[midIndex]) {
  634.  
  635.                             beginIndex = midIndex + ;
  636.  
  637.                      } else {
  638.  
  639.                             return midIndex;
  640.  
  641.                      }
  642.  
  643.               }
  644.  
  645.               return -;
  646.  
  647.        }
  648.  
  649.        public static void main(String[] args) {
  650.  
  651.               SortTest sortTest = new SortTest();
  652.  
  653.               int[] array = sortTest.createArray();
  654.  
  655.               System.out.println("==========冒泡排序后(正序)==========");
  656.  
  657.               sortTest.bubbleSort(array, "asc");
  658.  
  659.               System.out.println("==========冒泡排序后(倒序)==========");
  660.  
  661.               sortTest.bubbleSort(array, "desc");
  662.  
  663.               array = sortTest.createArray();
  664.  
  665.               System.out.println("==========倒转数组后==========");
  666.  
  667.               sortTest.reverse(array);
  668.  
  669.               array = sortTest.createArray();
  670.  
  671.               System.out.println("==========选择排序后(正序)==========");
  672.  
  673.               sortTest.selectSort(array, "asc");
  674.  
  675.               System.out.println("==========选择排序后(倒序)==========");
  676.  
  677.               sortTest.selectSort(array, "desc");
  678.  
  679.               array = sortTest.createArray();
  680.  
  681.               System.out.println("==========插入排序后(正序)==========");
  682.  
  683.               sortTest.insertSort(array, "asc");
  684.  
  685.               System.out.println("==========插入排序后(倒序)==========");
  686.  
  687.               sortTest.insertSort(array, "desc");
  688.  
  689.               array = sortTest.createArray();
  690.  
  691.               System.out.println("==========快速排序后(正序)==========");
  692.  
  693.               sortTest.quickSort(array, "asc");
  694.  
  695.               sortTest.printArray(array);
  696.  
  697.               System.out.println("==========快速排序后(倒序)==========");
  698.  
  699.               sortTest.quickSort(array, "desc");
  700.  
  701.               sortTest.printArray(array);
  702.  
  703.               System.out.println("==========数组二分查找==========");
  704.  
  705.               System.out.println("您要找的数在第" + sortTest.binarySearch(array, )
  706.  
  707.                             + "个位子。（下标从0计算）");
  708.  
  709.        }
  710.  
  711. }
  712.  
  713. 转载地址：http://blog.csdn.net/lenotang/archive/2008/11/29/3411346.aspx

JAVA排序总结的更多相关文章

  1. 常用Java排序算法

    常用Java排序算法 冒泡排序 .选择排序.快速排序 package com.javaee.corejava; public class DataSort { public DataSort() { ...

  2. java排序集锦

    java实现排序的一些方法,来自:http://www.javaeye.com/topic/548520 package sort; import java.util.Random; /** * 排序 ...

  3. Java排序算法之直接选择排序

    Java排序算法之直接选择排序 基本过程:假设一序列为R[0]~R[n-1],第一次用R[0]和R[1]~R[n-1]相比较,若小于R[0],则交换至R[0]位置上.第二次从R[1]~R[n-1]中选 ...

  4. (转)JAVA排序汇总

    JAVA排序汇总 package com.softeem.jbs.lesson4; import java.util.Random; /** * 排序测试类 * * 排序算法的分类如下: * 1.插入 ...

  5. java排序算法（一）：概述

    java排序算法(一)概述 排序是程序开发中一种非常常见的操作,对一组任意的数据元素(活记录)经过排序操作后,就可以把它们变成一组按关键字排序的一组有序序列 对一个排序的算法来说,一般从下面三个方面来 ...

  6. java排序算法（十）：桶式排序

    java排序算法(十):桶式排序 桶式排序不再是一种基于比较的排序方法,它是一种比较巧妙的排序方式,但这种排序方式需要待排序的序列满足以下两个特征: 待排序列所有的值处于一个可枚举的范围之类: 待排序 ...

  7. java排序算法（九）：归并排序

    java排序算法(九):归并排序

  8. java排序算法（八）：希尔排序（shell排序）

    java排序算法(八):希尔排序(shell排序) 希尔排序(缩小增量法)属于插入类排序,由shell提出,希尔排序对直接插入排序进行了简单的改进,它通过加大插入排序中元素之间的间隔,并在这些有间隔的 ...

  9. java排序算法（七）：折半插入排序

    java排序算法(七):折半插入排序 折半插入排序法又称为二分插入排序法,是直接插入排序法的改良版本,也需要执行i-1趟插入.不同之处在于第i趟插入.先找出第i+1个元素应该插入的位置.假设前i个数据 ...

  10. java排序算法（六）：直接插入排序

    java排序算法(六):直接插入排序 直接插入排序的基本操作就是将待的数据元素按其关键字的大小插入到前面的有序序列中 直接插入排序时间效率并不高,如果在最坏的情况下,所有元素的比较次数的总和为(0+1 ...

随机推荐

  1. Git：远程仓库的使用

    查看当前的远程库 要查看当前配置有哪些远程仓库,可以用git remote 命令,它会列出每个远程库的简短名字.在克隆完某个项目后,至少可以看到一个名为origin 的远程库,Git 默认使用这个名字 ...

  2. 将应用升级到了 Spring 4.1.0+quartz-2.2.1 还是很给力一样的兼容

    应用采用了集群3个tomcat,一个weblogic12c 后台数据应用

  3. insert into select 多个表

    INSERT INTO user_auth(userid, auth_plane_id) select user.user_id AS userid, plane.id AS auth_plane_i ...

  4. Android 常用的数据加密方式

    前言 Android 很多场合需要使用到数据加密,比如:本地登录密码加密,网络传输数据加密,等.在android 中一般的加密方式有如下: 亦或加密 AES加密 RSA非对称加密 当然还有其他的方式, ...

  5. Java命令学习系列（七）——javap

    javap是jdk自带的一个工具,可以对代码反编译,也可以查看java编译器生成的字节码. 一般情况下,很少有人使用javap对class文件进行反编译,因为有很多成熟的反编译工具可以使用,比如jad ...

  6. YAML文件简介

    编程免不了要写配置文件,怎么写配置也是一门学问. YAML 是专门用来写配置文件的语言,非常简洁和强大,远比 JSON 格式方便. 本文介绍 YAML 的语法,以 JS-YAML 的实现为例.你可以去 ...

  7. Django model 中设置联合约束和联合索引

    来自:https://blog.csdn.net/ding_312/article/details/81264910 class Cart(models.Model): user = models.F ...

  8. Swift3.0：照片选择

    一.介绍 图片选择或者拍照功能: 1.选择相册中的图片或是拍照,都是通过UIImagePickerController控制器实例化一个对象,然后通过self.presentViewController ...

  9. 第四章 dubbo内核之aop源码解析

    ExtensionLoader<Protocol> loader = ExtensionLoader.getExtensionLoader(Protocol.class); final P ...

  10. CSV 数字转化文本

    最近遇到一个Bug问题,csv 数值转化为文本的问题. 数据如下: 运行效果 如下: 大家看到“01720” 前面的0 没有显示出来.怎样才能显示出来了, 这里的csv文件格式也没有什么问题.后来找到 ...