Java对象排序及字符串排序

字符串排序

对象排序1-Map

实现了Comparator接口，重写了compare方法

对象排序2-自定义

实现了Comparable接口，重写了compareTo方法

java 排序面试题

一道常考的javaSE面试题上周一,.NET班有四个同学去面试，面试题是一道排序题，不管用什么方式做出结果就行。就这道题我也想些想法，当时他们和我说完，我在想用什么方法可以实现。毕竟现在javaSE都忘的差不多了，现在主要学的还是javaEE方面。年前学习JSP和SERVLET一片的知识，到了年后主要学习三大框架、ajax、jquery和XML等。不过当时出现脑中的算法只有：java.util包中定义的Arrays类和冒泡法。下面就拿上面方说的那两种方法具体说说。在JDK的java.util包中定义的Arrays类提供了多种数据操作方法，实现了对数组元素的排序、填充、转换、增强检索和深度比较等功能，所以的这些方法都是static的，下面介绍对数组元素进行排序的方法。数组元素的排序通常是指一维数值型数组元素按升序排序，偶尔也会涉及一维String数组排序，一般来说，多维和其他引用类型的元素数组排序使用意义不大。 Arrays类中的sort()的格式： public static void sort([] a); 案例1： JDK的java.util包中定义的Arrays类提供了排序方法一维数组排序： Java代码 1.package cn.z_xiaofei168.sort; 2. 3.import java.util.Arrays; 4. 5.public class TestArraySort { 6. 7./** 8. * @author z_xiaofei168 9. */ 10.public static void main(String[] args) { 11.int[] arr = { -1, -3, 5, 7, 9, 2, 4, 6, 8, 10 }; 12. System.out.print("整数排序前："); 13. displayIntArr(arr); 14. Arrays.sort(arr); 15. System.out.print("整数排序后："); 16. displayIntArr(arr); 17.

排序算法原理与实现(java)

Java程序员必知的8大排序<合肥软件培训> [来源：本站| 日期：2012年12月24日| 浏览173次] 字体:[大中小] 8种排序之间的关系: 1，直接插入排序（1）基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。（2）实例（3）用java实现 //从小到大 package com.njue;

2 3public class insertSort { 4public insertSort(){ 5 inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51}; 6int temp=0; 7for(int i=1;i=0&&temp

《Java范例开发大全》

下面是377个Java的例子。如果你是牛人，看看你能做出多少？如果有人不相信这些例子都是Java做的，可以看看清华大学的《Java范例开发大全》实例1开发第一个Java程序实例2自动提升实例3自动转换实例4常用基础类型之强制转换实例5算术运算符实例6关系运算符实例7逻辑运算符实例8位运算符实例9移位运算符实例10转型运算符实例11常量与变量实例12各种进制的转换实例13 Java中的进制与移位运算符实例14判断输入的年份是否为闰年实例15抽奖活动实例16xx乘法表实例17如何列出素数实例18 Java中的递归实例19男生女生各多少人

实例20求xx数实例21求任意一个正数的阶乘实例22求n的n次方实例23利用for循环输出几何图形实例24xx 实例25求1到100之间的和实例26存上100元需要多少天实例27输出100之间的所有偶数实例28如何判断回文数字实例29输出100之间的所有奇数实例30求最大的随机数实例31判断字母分类实例32优良及差实例33打印任意一年日历实例34一年四季的划分实例35除0发生的算术异常（ArithmeticException）实例36数组下标越界异常（ArrayIndexOutOfBoundsException）实例37数组元素类型不匹配异常（ArrayStoreException）实例38强制类型转换异常（ClassCastException）实例39索引越界异常（IndexOutOfBoundsException）实例40空指针异常（NullPointerException）

java中的各种排序案例

一、插入排序 1、基本思想插入排序（以升序为例）的基本操作是将一个数插入到一个已经排好序的数据序列中，插入后的数据序列是有序的并且元素个数加一。插入排序的主要思想是：假设要排序的数组为A[]元素个数为n，将这个数组分为两个部分前n-1个元素和最后一个元素，将最后一个元素插入到已经排好序的n-1个元素中的合适的位置。 InsertSort(A[n]) //对A[n]进行插入排序 { for i=1 to n divide(A[i-1],a[i]) //将A[i]分为两部分，前i-1个元素和最后一个元素 Insert(a[i],A[i-1])//将最后一个元素插入到排好序的前i-1个元素中 } 2、算法复杂度分析插入排序存在着最好情况和最坏情况，最好的情况是已经是排好序的了，这时只需比较n-1次即可；最坏的情况是序列是降序的需要排成升序的，那么此时就需要比较n(n-1)/2。插入排序的赋值操作是比较操作的次数加上n-1次。平均来说插入排序的算法复杂度为O(n2)。 3、编程实现 public static void InsertSort(int[] A){ for(int i=1;i0&&A[j-1]>=temp){ A[j]=A[j-1]; j--; } A[j]=temp; } } 二、冒泡排序 1、基本思想冒泡排序（以升序为例）的基本思想是：依次比较相邻的两个数，将小数放在前面，大数放在后面，第一轮比较后，最大的数便被放到了最后；第二轮操作前n-1个数据（假设有n个数据），依然是依次比较相邻的两个数，将小数放在前面，大数放在后面，倒数第二个数便是第二大的数；同理第i轮操作前n-i+1的数据（假设i取值是从1开始的），则n-i+i位置上的数据为第i大的数据。一共有n-1轮，第i轮比较中共比较n-i次比较。 BubbleSort(A[n]) { for(i=1;iA[j+1]) A[j]?A[j+1];//交换次序 } 2、算法复杂度分析

Java程序员必知的8大排序(上)

Java程序员必知的8大排序(上) 本文主要详解了Java语言的8大排序的基本思想以及实例解读，详细请看下文 AD：8种排序之间的关系: 1，直接插入排序（1）基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。（2）实例

（3）用java实现 1package com.njue; 2 3public class insertSort { 4public insertSort(){ 5 inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,3 4,15,35,25,53,51}; 6int temp=0; 7for(int i=1;i=0&&temp

JAVA数组的排序方法实例

冒泡排序法 1.public class SortArray_01 { 2. public static void main(String args[]) { 3. int[] array = { 14, 5, 86, 4, 12, 3, 21, 13, 11, 2, 55 }; // 创建一个初始化的一维数组array 4. System.out.println("未排序的数组:"); 5. for (int i = 0; i < array.length; i++) { // 遍历array数组中的元素 6. System.out.print(" " + array[i]); // 输出数组元素 7. if ((i + 1) % 5 == 0) // 每5个元素一行 8. System.out.println(); 9. } 10. int mid; // 定义一个中间变量，起到临时存储数据的作用 11. for (int i = 0; i < array.length; i++) { // 执行冒泡排序法 12. for (int j = i; j < array.length; j++) { 13. if (array[j] < array[i]) { 14. mid = array[i]; 15. array[i] = array[j]; 16. array[j] = mid; 17. } 18. } 19. } 20. System.out.println("\n使用冒泡法排序后的数组:"); 21. for (int i = 0; i < array.length; i++) { // 遍历排好序的array数组中的元素 22. System.out.print(" " + array[i]); // 输出数组元素 23. if ((i + 1) % 5 == 0) 24. System.out.println(); // 每5 个元素一行 25. } 26. } 27.} 数组递增排序

java二分法查找案例与数组排序案例

一、一个int类型数组按升序排序案例 public class ArrayTest { private static int[] arrayAesc; public static void main(String[] args) { ArrayTest a = new ArrayTest(); arrayAesc = new int[]{5,2,1,4,6,3}; arrayAesc = a.sortArrayAesc(arrayAesc); for (int i = 0; i < arrayAesc.length; i++) { System.out.println(arrayAesc[i]); } System.out.println("success"); } public int[] sortArrayAesc(int[] temps){ for (int i = 0; i < temps.length; i++) { for (int j = i+1; j < temps.length; j++) { if (temps[i] > temps[j]) { int temp; temp = temps[i]; temps[i] = temps[j]; temps[j] = temp; } } } return temps; } } 二、一个int类型数组按降序排序案例 public class ArrayTest { private static int[] arrayAesc; public static void main(String[] args) { ArrayTest a = new ArrayTest(); arrayAesc = new int[]{5,2,1,4,6,3}; arrayAesc = a.sortArrayDesc(arrayAesc); for (int i = 0; i < arrayAesc.length; i++) { System.out.println(arrayAesc[i]); } System.out.println("success"); }

JAVA中运用数组的四种排序方法

JAVA中在运用数组进行排序功能时，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。快速排序法主要是运用了Arrays中的一个方法Arrays.sort（）实现。冒泡法是运用遍历数组进行比较，通过不断的比较将最小值或者最大值一个一个的遍历出来。选择排序法是将数组的第一个数据作为最大或者最小的值，然后通过比较循环，输出有序的数组。插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。下面我就将他们的实现方法一一详解供大家参考。 <1>利用Arrays带有的排序方法快速排序 import java.util.Arrays; publicclass Test2{ publicstaticvoid main(String[] args){ int[] a={5,4,2,4,9,1}; Arrays.sort(a); //进行排序 for(int i: a){ System.out.print(i); } } } <2>冒泡排序算法 publicstaticint[] bubbleSort(int[] args){//冒泡排序算法 for(int i=0;iargs[j]){ int temp=args[i]; args[i]=args[j]; args[j]=temp; } } } return args; } <3>选择排序算法 publicstaticint[] selectSort(int[] args){//选择排序算法 for (int i=0;i

java的七种经典排序

此文中的七种排序算法为个人总结，程序均在eclipse中验证成功，可供参考 package sort; /* * 各种排序方法总结 */ public class Sort { public static void main(String[] args) { int[] array={4,9,6,7,2,3,1,5,8,0}; Sort.heapSort(array); for(int i=0;i array[index]) { index = j; } } int temp = array[array.length - i - 1]; array[array.length - i - 1] = array[index]; array[index] = temp; } return array; } public static int[] selectSort1(int[] array) { for (int i = 0; i < array.length; i++) { int minIndex = i; for (int j = i + 1; j < array.length; j++) {

java中8大排序方法

Java程序员必知的8大排序本文主要详解了Java语言的8大排序的基本思想以及实例解读，详细请看下文8种排序之间的关系: 1，直接插入排序（1）基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。（2）实例

（3）用java实现 1.package com.njue; 2. 3.public class insertSort { 4.public insertSort(){ 5. inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17, 18,23,34,15,35,25,53,51}; 6.int temp=0; 7.for(int i=1;i=0&&temp

java中几种简单的排序

** 大家好，我现在正在学习，虽然在这之前我已经学习过一遍了，但是现在再重新来学，才发现以前学地太肤浅了，而且学地质量也很不好，所以，现在我又重新站在了新地起跑线上，开始了我地学习之旅，喜欢地朋友和想学习地朋友来和我一起前进吧.我会及时地把自己学地一些东西总结出来，并传送到文库中和大家一起分享地. 所以地时候到了，，！（我地号，愿意交流地同学可以加我呦) 中地几种排序方法：冒泡排序，选择排序，插入排序和快速排序.下面是我当初开始学时地一些源代码，简单易懂，拿出来分享给大家，希望对刚接触地人能够有所帮助.b5E2R。在此，也和大家共勉一下：相信自己，用心学习，大胆创新！ * .*首先是冒泡排序，冒泡排序地思想是：数组中地相邻地两个数进行比较，如果后面地数比前面地数大，则两个数进行交换，每完成一次循环，最大地那个数就排在了最后面；以此类推，在第次循环后，数组中地个数就排好了.下面是源代码p1Ean。 * {

([] ){ [] {}; ( <){ ([]); } ( <){ ( <){ ([]<[]){ []; [][]; []; } } } (); ( <){ ([]); } } } *.其次是选择排序.选择排序地思想是记录下数组中最小地那个数地下标，然后与第一个数进行交换，以此类推，直到

排好序为止.下面是源代码DXDiT。* { ([] ){ [] {}; ( <){ ([]); } 排序 ( <){ (); (); } (); ( <){ ([]); } } 找到最小地数地下标 ([] ){ []; ;

( <){ ([]<){ []; ; } } ; } 两个数进行交换 ([] ){ []; [][]; []; } } *.然后是插入排序.插入排序地基本思想是：新建一个数组，将需要排序地数组地第一个元素先放到新数组中去，然后把剩下地元素有序地、依次插入到新数组中去.下面是源代码RTCrp。 * { ([] ){ [] {};

java中数组常见的排序问题整理

本文由我司收集整编，推荐下载，如有疑问，请与我司联系 java 中数组常见的排序问题整理 2016/03/13 0 span > 1.选择排序：选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法。如图所示：数组array 有5 个元素首先，array[0]与array[1]比较大小，如果array[0] array[1],则将两元素互换位置，然后再将array[0]与array[2]进行比较，一次进行下去，当第一轮循环完成，则 array[0]是数组中最小的元素。然后开始拿array[1]与array[2]进行比较，依次下去，比较到最后即可。程序代码实现如下： public void SelectionSort(int[] array){for(int i=0;i array.length-1;i++){for(int j=i+1;j array.length;j++){int temp;if(array[i] array[j]){temp = array[i];array[i]=array[j];array[j]=temp;}}}}2.冒泡排序：它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。下面用一张图来详细说明冒泡的原理。如图：数组array 有五个元素，int[] array={7,5,12,9,2}; 第一步还是和选择排序一样，先是array[0]和array[1]进行比较，如果array[0] array[1],两个元素互换位置，即array[0]=5,array[1]=7；第二步，array[1]和array[2]进行比较大小，array[1] array[2],位置不变；第三步，array[2]和array[3]比较，array[2] array[3],位置互换；array[3]与array[4]比较，array[3] array[4],位置互换，第一轮循环结束，我们会发现，数组的最后一个元素是数组中最大的。第一轮循环完成后的数组变成如下图所示：接下来继续又从array[0]和array[1]开始比较，重复下去。第一轮比较得出了最

Java各种排序算法

Java排序算法 1）分类： 1）插入排序（直接插入排序、希尔排序） 2）交换排序（冒泡排序、快速排序） 3）选择排序（直接选择排序、堆排序） 4）归并排序 5）分配排序（箱排序、基数排序）所需辅助空间最多：归并排序所需辅助空间最少：堆排序平均速度最快：快速排序不稳定：快速排序，希尔排序，堆排序。 1）选择排序算法的时候 1.数据的规模； 2.数据的类型； 3.数据已有的顺序一般来说，当数据规模较小时，应选择直接插入排序或冒泡排序。任何排序算法在数据量小时基本体现不出来差距。考虑数据的类型，比如如果全部是正整数，那么考虑使用桶排序为最优。考虑数据已有顺序，快排是一种不稳定的排序（当然可以改进），对于大部分排好的数据，快排会浪费大量不必要的步骤。数据量极小，而起已经基本排好序，冒泡是最佳选择。我们说快排好，是指大量随机数据下，快排效果最理想。而不是所有情况。 3）总结： ——按平均的时间性能来分： 1）时间复杂度为O(nlogn)的方法有：快速排序、堆排序和归并排序，其中以快速排序为最好； 2）时间复杂度为O(n2)的有：直接插入排序、起泡排序和简单选择排序，其中以直接插入为最好，特别是对那些对关键字近似有序的记录序列尤为如此； 3）时间复杂度为O(n)的排序方法只有，基数排序。当待排记录序列按关键字顺序有序时，直接插入排序和起泡排序能达到O(n)的时间复杂度;而对于快速排序而言，这是最不好的情况，此时的时间性能蜕化为O(n2)，因此是应该尽量避免的情况。简单选择排序、堆排序和归并排序的时间性能不随记录序列中关键字的分布而改变。 ——按平均的空间性能来分（指的是排序过程中所需的辅助空间大小）： 1）所有的简单排序方法(包括：直接插入、起泡和简单选择)和堆排序的空间复杂度为O(1)； 2）快速排序为O(log n )，为栈所需的辅助空间; 3）归并排序所需辅助空间最多，其空间复杂度为O(n ); 4）链式基数排序需附设队列首尾指针，则空间复杂度为O(rd )。 ——排序方法的稳定性能： 1）稳定的排序方法指的是，对于两个关键字相等的记录，它们在序列中的相对位置，在排序之前和经过排序之后，没有改变。 2）当对多关键字的记录序列进行LSD方法排序时，必须采用稳定的排序方法。 3）对于不稳定的排序方法，只要能举出一个实例说明即可。 4）快速排序，希尔排序和堆排序是不稳定的排序方法。 4）插入排序：包括直接插入排序，希尔插入排序。直接插入排序：将一个记录插入到已经排序好的有序表中。 1, sorted数组的第0个位置没有放数据。

java中常用的七大排序算法

java中常用的七大排序算法这段时间闲了下来，就抽了点时间总结了下java中常用的七大排序算法，希望以后可以回顾！ 1.插入排序算法插入排序的基本思想是在遍历数组的过程中，假设在序号i之前的元素即[0..i-1] 都已经排好序，本趟需要找到i对应的元素x 的正确位置k ，并且在寻找这个位置k 的过程中逐个将比较过的元素往后移一位，为元素x “腾位置”，最后将k 对应的元素值赋为x ，一般情况下，插入排序的时间复杂度和空间复杂度分别为O(n2) 和O(1)。 /** * @paramint[] 未排序数组 * @return int[] 排完序数组 */ publicint[] sortInsert(int[] array){ for(inti=1;i= 0 &&temp< array[j]; j--){ array[j + 1] = array[j]; } array[j + 1] = temp; } return array; } 2.选择排序算法选择排序的基本思想是遍历数组的过程中，以i代表当前需要排序的序号，则需要在剩余的[i…n-1] 中找出其中的最小值，然后将找到的最小值与i指向的值进行交换。因为每一趟确定元素的过程中都会有一个选择最大值的子流程，所以人们形象地称之为选择排序。选择排序的时间复杂度和空间复杂度分别为O(n2)和O(1)。 /** * @paramint[] 未排序数组 * @return int[] 排完序数组 */ publicint[] sortSelect(int[] arr){ for (inti = 0; iarr[miniPost]) { int temp;

用java编写的排序程序

public class PaiXu{ /** * @author zongyanshan * @since 20130725 */ public static void main(String[] args) { // TODO Auto-generated method stub int[] num = { 2, 9, 3, 1, 7, 4 }; // PopSortTest.popSort(num); // PopSortTest.chioseSort(num); // PopSortTest.insertSort(num); PopSortTest.shellSort(num); for (int i = 0; i < num.length; i++) { System.out.println(num[i]); } } // 冒泡排序法 public static int[] popSort(int num[]) { int temp; for (int i = 0; i < num.length; i++) { for (int j = 0; j < num.length - 1; j++) { temp = num[j]; if (num[j + 1] > num[j]) { num[j] = num[j + 1]; num[j + 1] = temp; } } } return num; } // 选择排序法 public static void choiceSort(int num[]) { int temp = 0; for (int i = 0; i < num.length; i++) { for (int j = i; j < num.length - 1; j++) { temp = num[i]; if (num[j + 1] > temp) { int temp2 = temp; temp = num[j + 1]; num[j + 1] = temp2; }

Java实现的常见排序算法

以下内容节选自Java私塾自编经典教材：下面是Java实现的一些常见排序算法。 1：冒泡排序对几个无序的数字进行排序，比较常用的方法是冒泡排序法。冒泡法排序是一个比较简单的排序方法，在待排序的数列基本有序的情况下排序速度较快。基本思路：对未排序的各元素从头到尾依次比较相邻的两个元素是否逆序（与欲排顺序相反），若逆序就交换这两元素，经过第一轮比较排序后便可把最大（或最小）的元素排好，然后再用同样的方法把剩下的元素逐个进行比较，就得到了你所要的顺序。可以看出如果有N个元素，那么一共要进行N-1轮比较，第I轮要进行N-I次比较。（如：有5个元素，则要进行5-1轮比较。第3轮则要进行5-3次比较）示例如下： public class Test { public static void main(String[] args) { //需要排序的数组，目前是按照升序排列的 int a[] = new int[5]; a[0] = 3; a[1] = 4; a[2] = 1; a[3] = 5; a[4] = 2; //冒泡排序 for(int i=0;i a[j]){ int temp = a[j]; a[j] = a[i]; a[i] = temp; } } } //检测一下排序的结果 for(int i : a){ System.out.println("i="+i); } } } 运行结果： i=1 i=2

冒泡排序法、选择排序法、插入排序法(java案例详解)

1.冒泡排序法 /** *功能：冒泡排序法 *思想：通过对待排序序列从后向前（从下标较大的元素开始），依次比较相邻元素的排序码， *，若发现逆序这交换，使得排序码较小的元素逐渐从后部移向前部（从下标较大的单元移向下标） *较小的单元，，就像水底下的气泡一样逐渐向上冒。 *作者：徐守威 */ package com.xushouwei; public class T4 { /** *@param args */ public static void main(String[] args) { // TODO Auto-generated method stub int arr1[]={1,6,0,-1,9,-100,90}; //开始排序,创建一个Bubble类 Bubble bubble=new Bubble(); bubble.sort(arr1); //输出最后结果 for(int i=0;i

//排序方法 public void sort(int arr[]) { //第一层循环用来指定排序的次数 //定义一个临时变量来存放交换的值 int temp=0; for(int i=0;iarr[j+1]) { //交换位置 temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp; } } } } } 2.选择排序法 /** *功能：选择排序法 *思想：第一次从R[0]-R[N-1]中选取最小值，与R[0]交换，第二次从 R[1]-R[N-1]中选取最小值，与R[1]交换， *第三次从R[2]-R[N-1]中选取最小值，与R[2]交换...第i次从 R[i]-R[N-1]中选取最小值，与R[i-1]交换， *第n-1次从R[n-2]-R[N-1]中选取最小值，与R[n-2]交换，总共通过n-1

java排序算法大全

java排序算法大全为了便于管理，先引入个基础类： package algorithms; public abstract class Sorter> { public abstract void sort(E[] array,int from ,int len); public final void sort(E[] array) { sort(array,0,array.length); } protected final void swap(E[] array,int from ,int to) { E tmp=array[from]; array[from]=array[to]; array[to]=tmp; } } 一插入排序该算法在数据规模小的时候十分高效，该算法每次插入第K+1到前K个有序数组中一个合适位置，K从0开始到N-1,从而完成排序： package algorithms; /** * @author yovn */ public class InsertSorter> extends Sorter { /* (non-Javadoc) * @see algorithms.Sorter#sort(E[], int, int) */ public void sort(E[] array, int from, int len) { E tmp=null; for(int i=from+1;ifrom;j--) { if(https://www.360docs.net/doc/9e7160856.html,pareTo(array[j-1])<0) { array[j]=array[j-1]; } else break;

java排序123

java排序123 为了便于管理，先引入个基础类： package algorithms; public abstract class Sorter> { public abstract void sort(E[] array,int from ,int len); public final void sort(E[] array) { sort(array,0,array.length); } protected final void swap(E[] array,int from ,int to) { E tmp=array[from]; array[from]=array[to]; array[to]=tmp; } } 一插入排序该算法在数据规模小的时候十分高效，该算法每次插入第K+1到前K个有序数组中一个合适位置，K从0开始到N-1,从而完成排序： package algorithms; /** * @author yovn */ public class InsertSorter> extends Sorter { /* (non-Javadoc) * @see algorithms.Sorter#sort(E[], int, int) */ public void sort(E[] array, int from, int len) { E tmp=null; for(int i=from+1;ifrom;j--) { if(https://www.360docs.net/doc/9e7160856.html,pareTo(array[j-1])<0) { array[j]=array[j-1]; } else break;

排序方法及其例子

其他拓扑排序 | 排序网络 | Bitonic sorter | Batcher odd-even mergesort | Pancake sorting 一、排序 1.冒泡法： .. 使用冒泡排序为一列数字进行排序的过程分类排序算法数据结构数组最差时间复杂度O(n2)最优时间复杂度O(n)平均时间复杂度O(n2)最差空间复杂度O(n) total, O(1) auxiliary public static void sort(Comparable[] a) { int N = a.length; for(int i=0;i0;j--) if(a[j].compareTo(a[j-1])<=-1) exchange(a,j,j-1); else break; } 交换位置： public static void change(Comparable[] a,int from,int to) { Comparable t = a[from];

a[from] = a[to]; a[to] = t; } 判断是否已经有序： public static boolean isSorted(Comparable[] a) { for(int i=1;i