冒泡排序,插入排序,快速排序java实现和效率比较
- 格式：docx
- 大小：15.90 KB
- 文档页数：11
下载文档原格式
合集下载
排序算法比较
排序算法比较
排序算法的效率主要取决于算法的时间复杂度。
以下是常见的几种排序算法的时间复杂度和优缺点的对比：
1. 冒泡排序
冒泡排序的时间复杂度为O(n^2)。
优点是它的实现简单易懂，缺点是排序速度很慢，对大规模数据排序不太适用。
2. 插入排序
插入排序的时间复杂度也为 O(n^2)。
它的优点是适用于小数
据量的排序，缺点是对于大规模数据排序仍然效率不高。
3. 选择排序
选择排序的时间复杂度也为 O(n^2)。
它的优点是对于小数据
量的排序速度较快，但是因为其算法结构固定，所以其效率在大规模数据排序中表现不佳。
4. 快速排序
快速排序的时间复杂度为 O(nlogn)。
它是一种非常常用的排序算法，适用于大规模数据排序。
快速排序的优点在于分治的思想，可以充分发挥多线程并行计算的优势，缺点是在极端情况下（如输入的数据已经有序或者逆序）排序速度会较慢。
5. 堆排序
堆排序的时间复杂度为 O(nlogn)。
它的优点在于实现简单、稳定，可以用于实时系统中的排序。
缺点是在排序过程中需要使用一个堆结构来维护排序序列，需要额外的内存开销。
同时，由于堆的性质，堆排序不能发挥多线程并行计算的优势。
6. 归并排序
归并排序的时间复杂度为 O(nlogn)。
它的优点在于稳定、可靠，效率在大规模数据排序中表现良好。
归并排序在实现过程中需要使用递归调用，需要额外的内存开销。
同时，归并排序不适用于链式存储结构。
冒泡排序java
冒泡排序java排序就是将输入的数字按照从小到大的顺序进行排列。
由于排序是一个比较基础的问题，所以排序算法的种类也比较多。
最近学习了几种常见的排序算法，下面介绍如何使用java代码实现对数组进行从下到大排序。
一、冒泡排序1、概念冒泡排序通过序列左边开始比较相邻位置数字的大小，左边数字大于右边了交换位置，只到最大的到最右边，然后再从左边开始比较相邻位置的数字，左边大于右边交换位置，只到最大的到右边第二个位置，循环操作，在这个过程中，数字会像泡泡一样，慢慢从左往右“浮”到序列的右端，所以这个算法才被称为“冒泡排序”。
看图解理解此概念很容易。
2、图解3、代码实现1public class BubbleSortTest {23public static void main(String[] args) {4int[] arr = new int[]{11, 2, 3, 5, 7, 4, 10, 8, 9};5 BubbleSort(arr);6 System.out.println(Arrays.toString(arr));7 }89private static void BubbleSort(int[] arr) {10//从右边开始循环遍历数组11for (int i = arr.length - 1; i > 0; i--) {12//遍历未排序的数组13for (int j = 0; j < i; j++) {14//相邻位置左边值大于右边，交换位置，将最大值最后换到待排序列最右边15if (arr[j] > arr[j + 1]) {16int temp = arr[j];17 arr[j] = arr[j + 1];18 arr[j + 1] = temp;19 }20 }21 }22 }23}二、选择排序1、概念选择排序就是从左边第一个开始，遍历右边序列找到最小的值与左边第一个数据交换位置，这样左边第一个数字就是整个序列最小的，然后从左边第二个开始，遍历右边的序列找到最小的值与左边第二个交换位置，依次类推，只到右边待排序的数据个数为0，结束循环，此时数组排序成功，因为每次循环后，左边的序列都是有序的。
常用排序算法分析比较
常用排序算法分析比较排序算法是计算机科学中的基本概念之一，它主要用于对一组元素进行排序，使得这些元素按照某种规则有序排列。
常见的排序算法包括冒泡排序、插入排序、选择排序、快速排序、归并排序等等，这些算法都有自己的特点和适用场景，下面针对这些排序算法进行分析比较。
1.冒泡排序冒泡排序是一种简单的排序算法，它的主要思想是依次比较相邻的两个元素，如果它们的顺序不对就交换它们的位置，可以保证每次循环后最后一个元素是已经排序好的。
冒泡排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
2.插入排序插入排序是一种稳定的排序算法，它的基本思想是将待排序的数据分为两个区间，已排序区间和未排序区间，在未排序区间内遍历，将每个元素插入到已排序区间的合适位置。
插入排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
3.选择排序选择排序是一种比较简单的排序算法，它的主要思想是通过不断选择未排序区间内的最小值，然后和未排序区间的第一个元素交换位置，以此类推，直到排序完毕。
选择排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
4.快速排序快速排序是一种经典的排序算法，它的思想是采用分治的思想，将序列分为左右两个子序列，通过递归的方式对左右两个子序列进行快速排序，最后合并两个排好序的子序列。
快速排序的时间复杂度为O(nlogn)，空间复杂度为O(logn)。
5.归并排序归并排序是一种稳定的排序算法，它的基本思想是采用分治的思想，将序列分为左右两个子序列，通过递归的方式对左右两个子序列进行排序，最后将两个排好序的子序列合并成一个有序序列。
归并排序的时间复杂度为O(nlogn)，空间复杂度为O(n)。
通过比较以上五种排序算法，可以发现每种算法都有自己的特点和适用场景，对于元素数量较少的情况下，可以选择冒泡排序、插入排序或选择排序，这些算法思路简单易懂，实现也比较容易；对于大规模数据排序，可以选择归并排序或快速排序，因为它们的时间复杂度比较优秀。
java 排序方法
java 排序方法在Java编程中，排序是一项非常常见的操作。
它可以帮助我们将一组数据按照特定的顺序进行排列，使得数据更易于查找和分析。
在Java中，有多种排序方法可以使用，每种方法都有其特点和适用场景。
接下来，我们将介绍几种常见的Java排序方法，帮助您更好地理解和使用它们。
首先，我们来介绍最常见的排序方法之一，冒泡排序。
冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。
通过多次的遍历和比较，最终实现整个数列的排序。
冒泡排序的时间复杂度为O(n^2)，在数据量较小的情况下是一个不错的选择。
其次，我们要介绍的是插入排序。
插入排序的基本思想是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增加1的有序表。
插入排序的时间复杂度也是O(n^2)，但是在实际应用中，当数据规模较小时，插入排序通常比冒泡排序更快。
另外，我们还有快速排序这一高效的排序方法。
快速排序使用分治法策略来把一个序列分为两个子序列，然后递归地对子序列进行排序。
快速排序的时间复杂度为O(nlogn)，在大多数情况下都比冒泡排序和插入排序更快速。
除了上述几种排序方法外，Java中还有很多其他的排序算法，比如选择排序、归并排序、堆排序等。
每种排序方法都有其适用的场景和特点，我们需要根据实际情况选择合适的排序算法来提高程序的效率。
在实际编程中，我们可以使用Java提供的Arrays.sort()方法来进行排序操作。
这个方法底层使用了快速排序和归并排序等高效的排序算法，能够满足大部分排序需求。
另外，我们也可以实现Comparator接口来自定义排序规则，以应对一些特殊的排序需求。
总的来说，排序是Java编程中一个非常重要的部分，掌握不同的排序方法对于提高程序的效率和性能至关重要。
通过本文介绍的几种常见的排序方法，相信大家对Java中的排序有了更深入的了解，希望能够在实际编程中加以运用，提高程序的质量和效率。
各种内排序算法的实验心得
各种内排序算法的实验心得
1. 冒泡排序
冒泡排序是一种简单的排序算法，但它的时间复杂度为O(n^2)，在处理大量数据时效率很低。
在实验过程中，我发现当数据量较小时，冒泡排序的效率其实还是不错的，但一旦数据量增加，它的效率就明显下降了。
2. 插入排序
插入排序的时间复杂度也是O(n^2)，类似于冒泡排序。
但是插入排序比冒泡排序更快，因为它每次只需要比较一个元素。
在实验中，我发现当数据量比较小且有序时，插入排序的效率非常高，但如果数据量较大且随机分布，效率就会明显下降。
3. 选择排序
选择排序同样是时间复杂度为O(n^2)的算法，但是它比冒泡排序和插入排序都要快。
在实验中，我发现当数据量很大时，选择排序的效率比较稳定，但是当数据量比较小时，它的效率反而不如插入排序。
4. 快速排序
快速排序是一种常用的排序算法，它的时间复杂度为O(nlogn)，比冒泡、插入和选择排序都要快。
在实验中，我发现当数据量比较大时，快速排序的效率非常高，但是当数据量比较小时，它的效率反而不如插入排序和选择排序。
5. 归并排序
归并排序与快速排序的时间复杂度相同，都是O(nlogn)。
但是归并排序比快速排序更稳定，因为它的最坏时间复杂度是O(nlogn)。
在实验中，我发现当数据量比较大时，归并排序的效率非常高，而且在处理大量数据时表现优异。
6. 基数排序
基数排序是一种特殊的排序算法，它适用于数据量较大且每个元素长度相同的情况。
在实验中，我发现基数排序的效率非常高，尤其是对于大量数据的排序。
但需要注意的是，基数排序无法处理字符串等非数字类型的数据。
用java解析冒泡排序,选择排序,快速排序方法
// Auto-generated method stub
int baseValue = array[start];
int j = end;
int i = start;
while (i < j) {
while (array[j] > baseValue && j > i)
arr[arr.length-1-i]=temp;
}
}
return arr; } 源自(3)快速排序(Quick
* Sort)：设要排序的数组是array[0…n-1]，首先任意选取一个数据（通常选用array[0]）作为基准数据，然后开始遍历数组
* ……
* 第arr.length-1轮，最大值放到第二位。
* 通过冒泡排序的实现：1.确定外循环的次数，经过演示发现，外循环的次数等于数组长度-1；
* 2.确定内循环，比较索引从0开始，到arr.length-外循环轮数
//使用冒泡排序对指定数组进行排序
/**
* 冒泡排序的思想：第一轮排序：索引从0开始到最后，前一个元素和后一个元素进行比较，如果符合条件就进行换位处理
* 那么最大值就会被排到数组的最后。
* 第二轮排序：最后一个元素 没有必要比较了，索引从0开始，到arr.leng-1.如果符合条件就进行换位处理，那么，最大值被排到倒数第二位。
if(arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
return arr;
int baseValue = array[start];
int j = end;
int i = start;
while (i < j) {
while (array[j] > baseValue && j > i)
arr[arr.length-1-i]=temp;
}
}
return arr; } 源自(3)快速排序(Quick
* Sort)：设要排序的数组是array[0…n-1]，首先任意选取一个数据（通常选用array[0]）作为基准数据，然后开始遍历数组
* ……
* 第arr.length-1轮，最大值放到第二位。
* 通过冒泡排序的实现：1.确定外循环的次数，经过演示发现，外循环的次数等于数组长度-1；
* 2.确定内循环，比较索引从0开始，到arr.length-外循环轮数
//使用冒泡排序对指定数组进行排序
/**
* 冒泡排序的思想：第一轮排序：索引从0开始到最后，前一个元素和后一个元素进行比较，如果符合条件就进行换位处理
* 那么最大值就会被排到数组的最后。
* 第二轮排序：最后一个元素 没有必要比较了，索引从0开始，到arr.leng-1.如果符合条件就进行换位处理，那么，最大值被排到倒数第二位。
if(arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
return arr;
数据结构之各种排序的实现与效率分析
各种排序的实现与效率分析一、排序原理（1）直接插入排序基本原理：这是最简单的一种排序方法，它的基本操作是将一个记录插入到已排好的有序表中，从而得到一个新的、记录增1的有序表。
效率分析：该排序算法简洁，易于实现。
从空间来看，他只需要一个记录的辅助空间，即空间复杂度为O（1）.从时间来看，排序的基本操作为：比较两个关键字的大小和移动记录。
当待排序列中记录按关键字非递减有序排列（即正序）时，所需进行关键字间的比较次数达最小值n-1，记录不需移动；反之，当待排序列中记录按关键字非递增有序排列（即逆序）时，总的比较次数达最大值（n+2）(n-1)/2，记录移动也达到最大值（n+4）(n-2)/2.由于待排记录是随机的，可取最大值与最小值的平均值，约为n²/4.则直接插入排序的时间复杂度为O（n²）.由此可知，直接插入排序的元素个数n越小越好，源序列排序度越高越好（正序时时间复杂度可提高至O（n））。
插入排序算法对于大数组，这种算法非常慢。
但是对于小数组，它比其他算法快。
其他算法因为待的数组元素很少，反而使得效率降低。
插入排序还有一个优点就是排序稳定。
（2）折半插入排序基本原理：折半插入是在直接插入排序的基础上实现的，不同的是折半插入排序在将数据插入一个有序表时，采用效率更高的“折半查找”来确定插入位置。
效率分析：由上可知该排序所需存储空间和直接插入排序相同。
从时间上比较，折半插入排序仅减少了关键字间的比较次数，为O(nlogn)。
而记录的移动次数不变。
因此，折半查找排序的时间复杂度为O(nlogn)+O（n²）= O（n²）。
排序稳定。
（3）希尔排序基本原理：希尔排序也一种插入排序类的方法，由于直接插入排序序列越短越好，源序列的排序度越好效率越高。
Shell 根据这两点分析结果进行了改进，将待排记录序列以一定的增量间隔dk 分割成多个子序列，对每个子序列分别进行一趟直接插入排序, 然后逐步减小分组的步长dk，对于每一个步长dk 下的各个子序列进行同样方法的排序,直到步长为1 时再进行一次整体排序。
各种排序方法的综合比较
各种排序方法的综合比较在计算机科学中，排序是一种常见的算法操作，它将一组数据按照特定的顺序重新排列。
不同的排序方法具有不同的适用场景和性能特点。
本文将综合比较几种常见的排序方法，包括冒泡排序、选择排序、插入排序、快速排序和归并排序。
一、冒泡排序冒泡排序是一种简单但效率较低的排序方法。
它通过多次遍历数组，每次比较相邻的两个元素，将较大的元素逐渐“冒泡”到数组的末尾。
冒泡排序的时间复杂度为O(n^2)，其中n为待排序元素的数量。
二、选择排序选择排序是一种简单且性能较优的排序方法。
它通过多次遍历数组，在每次遍历中选择最小的元素，并将其与当前位置交换。
选择排序的时间复杂度同样为O(n^2)。
三、插入排序插入排序是一种简单且适用于小规模数据的排序方法。
它通过将待排序元素逐个插入已排序的部分，最终得到完全有序的数组。
插入排序的时间复杂度为O(n^2)，但在实际应用中，它通常比冒泡排序和选择排序更快。
四、快速排序快速排序是一种高效的排序方法，它通过分治法将数组划分为两个子数组，其中一个子数组的所有元素都小于另一个子数组。
然后递归地对两个子数组进行排序，最终将整个数组排序完成。
快速排序的平均时间复杂度为O(nlogn)，但最坏情况下可能达到O(n^2)。
五、归并排序归并排序是一种稳定且高效的排序方法。
它通过将数组分成两个子数组，递归地对两个子数组进行排序，然后合并两个有序的子数组，得到最终排序结果。
归并排序的时间复杂度始终为O(nlogn)，但它需要额外的空间来存储临时数组。
综合比较上述几种排序方法，可以得出以下结论：1. 冒泡排序、选择排序和插入排序都属于简单排序方法，适用于小规模数据的排序。
它们的时间复杂度都为O(n^2)，但插入排序在实际应用中通常更快。
2. 快速排序和归并排序都属于高效排序方法，适用于大规模数据的排序。
它们的时间复杂度都为O(nlogn)，但快速排序的最坏情况下性能较差，而归并排序需要额外的空间。
8种排序算法
J=2(38) [38 49] 65 97 76 13 27 49
J=3(65) [38 49 65] 97 76 13 27 49
J=4(97) [38 49 65 97] 76 13 27 49
J=5(76) [38 49 65 76 97] 13 27 49
2. 堆的定义: N个元素的序列K1,K2,K3,...,Kn.称为堆，当且仅当该序列满足特性：
Ki≤K2i Ki ≤K2i+1(1≤ I≤ [N/2])
堆实质上是满足如下性质的完全二叉树：树中任一非叶子结点的关键字均大于等于其孩子结点的关键字。例如序列10,15,56,25,30,70就是一个堆，它对应的完全二叉树如上图所示。这种堆中根结点（称为堆顶）的关键字最小，我们把它称为小根堆。反之，若完全二叉树中任一非叶子结点的关键字均大于等于其孩子的关键字，则称之为大根堆。
(6)基数排序
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序，最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以其是稳定的排序算法。
2. 排序过程：
【示例】：
初始关键字 [49 38 65 97 76 13 27 49]
第一趟排序后 13 ［38 65 97 76 49 27 49]
第二趟排序后 13 27 ［65 97 76 49 38 49]
第三趟排序后 13 27 38 [97 76 49 65 49]
其次，说一下稳定性的好处。排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。另外，如果排序算法稳定，对基于比较的排序算法而言，元素交换的次数可能会少一些(个人感觉，没有证实)。
常用的java的排序算法
常用的java的排序算法Java作为一门非常流行的编程语言，在其标准库中封装了多种排序算法，这些算法广泛应用于各种开发场景。
下面，我们将重点介绍Java常用的排序算法。
常用的排序算法1. 冒泡排序冒泡排序是一种简单的排序算法，其基本思想是从数组的第一个元素开始，一次比较相邻的两个元素，如果它们的顺序错误，就交换它们的位置。
通过多次遍历整个数组，每次遍历都从第一个元素开始，一直到最后一个元素，把最大的元素“浮”到最后。
冒泡排序时间复杂度为O(n^2)，空间复杂度为O(1)。
2. 插入排序插入排序是另一种简单的排序算法，其基本思想是将一个元素插入到已经有序的数组中。
从数组中的每一个元素开始，比较元素的大小并将它们移动到正确的位置，直到整个数组有序。
插入排序时间复杂度为O(n^2)，空间复杂度为O(1)。
3. 快速排序快速排序是一种高效的排序算法，其基本思想是将一个数组分成两个子数组，然后递归地进行排序。
选择一个基准元素，将小于等于基准元素的放在左边，大于基准元素的放在右边，然后对左右两个子数组分别进行快速排序。
快速排序时间复杂度为O(nlogn)，空间复杂度为O(logn)。
4. 归并排序归并排序是一种稳定的排序算法，其基本思想是将一个数组分成两个子数组，然后递归地进行排序。
接着将两个子数组合并成一个有序的数组。
在合并时，比较两个元素的大小，将它们合并到一个新的数组中。
归并排序时间复杂度为O(nlogn)，空间复杂度为O(n)。
5. 堆排序堆排序是一种树形选择排序算法，其思想是利用堆这种数据结构来进行排序。
首先将数组中的元素构建成一个大根堆，然后将堆顶元素取出并放到数组的最后位置。
接着，重新调整堆，使其满足堆的性质。
堆排序时间复杂度为O(nlogn)，空间复杂度为O(1)。
总结以上这五种排序算法是Java中常用的排序算法，它们在不同的场景下有着不同的优缺点。
在选择排序算法时，需要根据实际情况做出选择。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
冒泡排序，插入排序，快速排序java实现和效率比较从测试结果看，冒泡算法明显不是一般的慢，10万数组的时候冒泡要4秒多，所以就百万就没用冒泡继续测试。
插入排序在结果中看来是最优的，为了方便比较，插入排序分别用了数组和list综合结果：list插入排序> 数组插入排序> 快速排序> > 冒泡排序输出结果：******万级测试******快速排序耗时：5list插入排序耗时：1数组插入排序耗时：1冒泡排序耗时：372******百万测试******快速排序耗时：118list插入排序耗时：1数组插入排序耗时：12[java] view plaincopyprint?1. import java.util.ArrayList;2. import java.util.List;3. import java.util.Random;4.5.6. public class SortPractice {7.8. public static void main(String[] args){9. System.out.println("******正确性测试******");10. Random random = new Random();11. SortPractice sp = new SortPractice ();12. int[] nums = new int[10];13. //生成随机整数数组14. for(int i = 0;i<nums.length;i++){15. nums[i] = random.nextInt();16. }17. //输出未排序的数组19. //输出排序后的数组20. sp.println(sp.sort(nums));21. sp.println(sp.insertSort(nums));22. sp.println(sp.insertSort(sp.toList(nums)));23. sp.println(sp.quickSort(sp.toList(nums)));24.25. System.out.println("******万级测试******");26. //万级排序时间测试27. nums = new int[10000];28. //生成随机整数数组29. for(int i = 0;i<nums.length;i++){30. nums[i] = random.nextInt();31. }32.33. List<Integer> list = sp.toList(nums);34. long begin = System.currentTimeMillis();35. sp.quickSort(list);36. System.out.println("快速排序耗时：\r\n"+(System.currentTimeMillis()-begin));37.38. list = sp.toList(nums);39. begin = System.currentTimeMillis();41. System.out.println("list插入排序耗时：\r\n"+(System.currentTimeMillis()-begin));42.43. begin = System.currentTimeMillis();44. sp.insertSort(nums);45. System.out.println("数组插入排序耗时：\r\n"+(System.currentTimeMillis()-begin));46.47. begin = System.currentTimeMillis();48. sp.sort(nums);49. System.out.println("冒泡排序耗时：\r\n"+(System.currentTimeMillis()-begin));50.51. System.out.println("******百万测试******");52. //百万级，排序时间测试53. nums = new int[1000000];54. //生成随机整数数组55. for(int i = 0;i<nums.length;i++){56. nums[i] = random.nextInt();57. }58.59. list = sp.toList(nums);60. begin = System.currentTimeMillis();61. sp.quickSort(list);62. System.out.println("快速排序耗时：\r\n"+(System.currentTimeMillis()-begin));63.64. list = sp.toList(nums);65. begin = System.currentTimeMillis();66. sp.insertSort(list);67. System.out.println("list插入排序耗时：\r\n"+(System.currentTimeMillis()-begin));68.69. begin = System.currentTimeMillis();70. sp.insertSort(nums);71. System.out.println("数组插入排序耗时：\r\n"+(System.currentTimeMillis()-begin));72. }73.74. /**75. * 冒泡排序76. * @param nums77. * @return78. */79. public int[] sort(int[] nums){80. int temp = 0;81. for(int i = 0; i < nums.length-1; i++){82. for(int j = i+1 ;j < nums.length; j++){83. if(nums[j]>nums[i]){85. nums[i] = nums[j];86. nums[j] = temp;87. }88. }89. }90. return nums;91. }92.93. /**94. * 插入排序95. * @param nums96. * @return97. */98. public int[] insertSort(int[] nums){99. int temp ;100. for(int i = 1;i<nums.length;i++){ 101. int j = i-1;102. temp = nums[i];103. while(j>=0&&temp>nums[j]){ 104. temp = nums[j];105. nums[j] = nums[i];107. j--;108. }109. }110.111. return nums;112. }113. /**114. * list插入排序115. * @param nums116. * @return117. */118. public List<Integer> insertSort(List<Integer> list){ 119. int temp ;120. for(int i = 1;i <list.size();i++){121. int j = i-1;122. temp = list.get(i);123. while(j >= 0 && temp > list.get(j)){124. temp = list.get(j);125. list.set(j,list.get(i));126. list.set(i,list.get(j));127. j--;128. }129. if(i>=1000) break;130. }131.132. return list;133. }134.135. /**136. * 快速排序法137. * @param nums138. * @return139. */140. public List<Integer> quickSort(List<Integer> list){ 141. Integer mid = list.get(new Random().nextInt(list.size())); 142. mid = list.get(5);143. List<Integer> small = new ArrayList<Integer>(); 144. List<Integer> big = new ArrayList<Integer>();145.146. for(int i = 0; i < list.size(); i++){147. if(list.get(i)<=mid){148. small.add(list.get(i));149. }else{150. big.add(list.get(i));151. }152. }153. list.clear();154. if(list.size()>2){155. list.addAll(quickSort(big));156. list.addAll(quickSort(small));157. }else{158. list.addAll(big);159. list.addAll(small);160. }161. return list;162. }163.164. /**165. * 数组转list166. * @param nums167. * @return168. */169. public List<Integer> toList(int[] nums){ 170. List<Integer> list = new ArrayList<Integer>(); 171. for(int i = 0; i < nums.length; i++){172. list.add(nums[i]);173. }174. return list;175. }176. /**177. * 打印数组178. * @param nums179. */180. public void println(int[] nums){ 181. System.out.println("-----");182. for(int i = 0;i<nums.length;i++){ 183. System.out.println(nums[i]);184. }185. }186.187.188. /**189. * 打印list190. * @param list191. */192. private void println(List<Integer> list) { 193. System.out.println("---------"); 194. for(Integer obj:list){195. System.out.println(obj);196. }197. }198.199. }。