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. log4j1修改DailyRollingFileAppender支持日志最大数量

    配置说明: log4j.appender.logfile=org.apache.log4j.MyDailyRollingFileAppender log4j.appender.logfile.File ...

  2. Java获取当前类名的两种方法

    适用于非静态方法:this.getClass().getName() 适用于静态方法:Thread.currentThread().getStackTrace()[1].getClassName() ...

  3. spring 4.1.4 发布

    Spring 框架今天发布了三个更新版本,分别是 4.1.4.4.0.9 和 3.2.13 版本. 这三个版本都是新年的维护版本,修复了各种小 bug,小改进等. via spring blog De ...

  4. 无耻之徒(美版)第一季/全集Shameless US迅雷下载

    第一季 Shameless Season 1 (2011)看点:本以为美版<无耻之徒>(Shameless)是小众剧(诸多儿童不宜),但是试播集98.2万的收视人次竟然创下了Showtim ...

  5. Asp.Net Core 视图整理(一)

    一.部分视图的使用 注:1.目前在Asp.Net Core2.0中对于部分视图的支持主要使用 Html.Partial()/Html.PartialAsync(); Html.RenderPartia ...

  6. python Genarator函数

    Generator函数的定义与普通函数的定义没有什么区别,只是在函数体内使用yield生成数据项即可.Generator函数可以被for循环遍历,而且可以通过next()方法获得yield生成的 数据 ...

  7. Python/Shell 正则表达式与运用

    正则表达式用的地方是很多的.比如字符串处理过程中.最近遇到记录一下. 1. 比如在shell中 #!/bin/bash str="date:2017-11-28 os:centos blac ...

  8. [leetcode]Multiply Strings @ Python

    原题地址:https://oj.leetcode.com/problems/multiply-strings/ 题意: Given two numbers represented as strings ...

  9. HTML5读取本地文件

    本文转自:转:http://hushicai.com/2014/03/29/html5-du-qu-ben-di-wen-jian.html感谢大神分享. 常见的语言比如php.shell等,是如何读 ...

  10. 引用外部jquery.js

    使用 Google 的 CDN <head> <script type="text/javascript" src="http://ajax.googl ...