Java中的快速排序一个简单的例子public class QuickSort { public static void sort(Comparable data, int low, int high) { // 枢纽元,一般以第一个元素为基准进行划分 Comparable pivotKey = data; // 进行扫描的指针i,j;i从左边开始,j从右边开始 int i = low; int j = high; if (low 《 high) { // 从数组两端交替地向中间扫描 while (i 《 j) { while (i 《 j && data.compareTo(pivotKey) 》 0) { j--; }// end while if (i 《 j) { // 比枢纽元素小的移动到左边 data; i++; }// end if while (i 《 j && data.compareTo(pivotKey) 《 0) { i++; }// end while if (i 《 j) { // 比枢纽元素大的移动到右边 data; j--; }// end if }// end while // 枢纽元素移动到正确位置 data = pivotKey; // 前半个子表递归排序 sort(data, low, i - 1); // 后半个子表递归排序 sort(data, i + 1, high); }// end if }// end sort public static void main(String args) { // 在JDK1.5版本以上,基本数据类型可以自动装箱 // int,double等基本类型的包装类已实现了Comparable接口 Comparable c = { 4, 9, 23, 1, 45, 27, 5, 2 }; sort(c, 0, c.length - 1); for (Comparable data : c) { System.out.println(data); } } } 真的是很服你，你把这个新建一个类放里面在主方法里面这样写：自己建个数组Comparable data, 定义参数int low, int highQuickSort qs = new QuickSort（）；qs.sort（ data, low, high）；

一、冒泡排序 view plain copypackage sort.bubble;import java.util.Random;/*** 依次比较相邻的两个数，将小数放在前面，大数放在后面* 冒泡排序，具有稳定性* 时间复杂度为O（n^2）* 不及堆排序，快速排序O（nlogn，底数为2）* @author liangge**/public class Main {public static void main(String args) {Random ran = new Random();int;for(int i = 0 ; i 《 10 ; i++){sort = ran.nextInt(50);}System.out.print(“排序前的数组为“);for(int i : sort){System.out.print(i+“ “);}buddleSort(sort);System.out.println();System.out.print(“排序后的数组为“);for(int i : sort){System.out.print(i+“ “);}}/*** 冒泡排序* @param sort*/private static void buddleSort(int sort){for(int i=1;i《sort.length;i++){for(int j=0;j《sort.length-i;j++){if(sort){int temp = sort;sort;sort = temp;}}}}} 二、选择排序 view plain copypackage sort.select;import java.util.Random;/*** 选择排序* 每一趟从待排序的数据元素中选出最小（或最大）的一个元素，* 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。* 选择排序是不稳定的排序方法。* @author liangge**/public class Main {public static void main(String args) {Random ran = new Random();int;for (int i = 0; i 《 10; i++) {sort = ran.nextInt(50);}System.out.print(“排序前的数组为“);for (int i : sort) {System.out.print(i + “ “);}selectSort(sort);System.out.println();System.out.print(“排序后的数组为“);for (int i : sort) {System.out.print(i + “ “);}}/*** 选择排序* @param sort*/private static void selectSort(int sort){for(int i =0;i《sort.length-1;i++){for(int j = i+1;j《sort.length;j++){if(sort){int temp = sort;sort;sort = temp;}}}}} 三、快速排序 view plain copypackage sort.quick;/*** 快速排序 通过一趟排序将要排序的数据分割成独立的两部分， 其中一部分的所有数据都比另外一部分的所有数据都要小，* 然后再按此方法对这两部分数据分别进行快速排序， 整个排序过程可以递归进行，以此达到整个数据变成有序序列。* @author liangge**/public class Main {public static void main(String args) {int sort = { 54, 31, 89, 33, 66, 12, 68, 20 };System.out.print(“排序前的数组为：“);for (int data : sort) {System.out.print(data + “ “);}System.out.println();quickSort(sort, 0, sort.length - 1);System.out.print(“排序后的数组为：“);for (int data : sort) {System.out.print(data + “ “);}}/*** 快速排序* @param sort 要排序的数组* @param start 排序的开始座标* @param end 排序的结束座标*/public static void quickSort(int sort, int start, int end) {// 设置关键数据key为要排序数组的第一个元素，// 即第一趟排序后，key右边的数全部比key大，key左边的数全部比key小int key = sort;// 设置数组左边的索引，往右移动判断比key大的数int i = start;// 设置数组右边的索引，往左移动判断比key小的数int j = end;// 如果左边索引比右边索引小，则还有数据没有排序while (i 《 j) {while (sort 》 key && j 》 start) {j--;}while (sort 《 key && i 《 end) {i++;}if (i 《 j) {int temp = sort;sort;sort = temp;}}// 如果左边索引比右边索引要大，说明第一次排序完成，将sort与key对换，// 即保持了key左边的数比key小，key右边的数比key大if (i 》 j) {int temp = sort;sort;sort = temp;}//递归调用if (j 》 start && j 《 end) {quickSort(sort, start, j - 1);quickSort(sort, j + 1, end);}}} view plain copy/*** 快速排序** @param a* @param low* @param high* voidTest*/public static void kuaisuSort(int a, int low, int high){if (low 》= high){return;}if ((high - low) == 1){if (a){swap(a, low, high);return;}}int key = a;int left = low + 1;int right = high;while (left 《 right){while (left 《 right && left 《= high)// 左边向右{if (a 》= key){break;}left++;}while (right 》= left && right 》 low){if (a 《= key){break;}right--;}if (left 《 right){swap(a, left, right);}}swap(a, low, right);kuaisuSort(a, low, right);kuaisuSort(a, right + 1, high);} 四、插入排序 view plain copypackage sort.insert;/*** 直接插入排序* 将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据* 算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。*/import java.util.Random;public class DirectMain {public static void main(String args) {Random ran = new Random();int;for (int i = 0; i 《 10; i++) {sort = ran.nextInt(50);}System.out.print(“排序前的数组为“);for (int i : sort) {System.out.print(i + “ “);}directInsertSort(sort);System.out.println();System.out.print(“排序后的数组为“);for (int i : sort) {System.out.print(i + “ “);}}/*** 直接插入排序** @param sort*/private static void directInsertSort(int sort) {for (int i = 1; i 《 sort.length; i++) {int index = i - 1;int temp = sort;while (index 》= 0 && sort 》 temp) {sort;index--;}sort = temp;}}} 顺便添加一份，差不多的 view plain copypublic static void charuSort(int a){int len = a.length;for (int i = 1; i 《 len; i++){int j;int temp = a;for (j = i; j 》 0; j--)//遍历i之前的数字{//如果之前的数字大于后面的数字，则把大的值赋到后面if (a 》 temp){a;} else{break;}}a = temp;}} 把上面整合起来的一份写法： view plain copy/*** 插入排序:**/public class InsertSort {public void sort(int data) {for (int i = 1; i 《 data.length; i++) {for (int j = i; (j 》 0) && (data); j--) {swap(data, j, j - 1);}}}private void swap(int data, int i, int j) {int temp = data;data;data = temp;}} 五、顺便贴个二分搜索法 view plain copypackage search.binary;public class Main {public static void main(String args) {int sort = {1,2,3,4,5,6,7,8,9,10};int mask = binarySearch(sort,6);System.out.println(mask);}/*** 二分搜索法，返回座标，不存在返回-1* @param sort* @return*/private static int binarySearch(int sort,int data){if(data《sort){return -1;}int begin = 0;int end = sort.length;int mid = (begin+end)/2;while(begin 《= end){mid = (begin+end)/2;if(data 》 sort){begin = mid + 1;}else if(data 《 sort){end = mid - 1;}else{return mid;}}return -1;}}

package Utils.Sort; /** * 快速排序，要求待排序的数组必须实现 Comparable 接口 */ public class QuickSort implements SortStrategy { private static final int CUTOFF = 3; // 当元素数大于此值时采用快速排序 /** * 利用快速排序算法对数组 obj 进行排序， 要求待排序的数组必须实现了 Comparable 接口 */ public void sort(Comparable = tmp; } }

java常见的排序分为：1 插入类排序主要就是对于一个已经有序的序列中，插入一个新的记录。它包括：直接插入排序，折半插入排序和希尔排序2 交换类排序这类排序的核心就是每次比较都要“交换”，在每一趟排序都会两两发生一系列的“交换”排序，但是每一趟排序都会让一个记录排序到它的最终位置上。它包括：起泡排序，快速排序3 选择类排序每一趟排序都从一系列数据中选择一个最大或最小的记录，将它放置到第一个或最后一个为位置交换，只有在选择后才交换，比起交换类排序，减少了交换记录的时间。属于它的排序：简单选择排序，堆排序4 归并类排序将两个或两个以上的有序序列合并成一个新的序列5 基数排序主要基于多个关键字排序的。下面针对上面所述的算法，讲解一些常用的java代码写的算法二 插入类排序之直接插入排序直接插入排序,一般对于已经有序的队列排序效果好。基本思想：每趟将一个待排序的关键字按照大小插入到已经排序好的位置上。算法思路，从后往前先找到要插入的位置，如果小于则就交换，将元素向后移动，将要插入数据插入该位置即可。时间复杂度为O(n2),空间复杂度为O(1)package sort.algorithm;public class DirectInsertSort { public static void main(String args) { // TODO Auto-generated method stub int data = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 }; int temp, j; for (int i = 1; i 《 data.length; i++) { temp = data; j = i - 1; // 每次比较都是对于已经有序的 while (j 》= 0 && data 》 temp) { data; j--; } data = temp; } // 输出排序好的数据 for (int k = 0; k 《 data.length; k++) { System.out.print(data + “ “); } }}三 插入类排序之折半插入排序(二分法排序)条件：在一个已经有序的队列中，插入一个新的元素折半插入排序记录的比较次数与初始序列无关思想：折半插入就是首先将队列中取最小位置low和最大位置high，然后算出中间位置mid将中间位置mid与待插入的数据data进行比较，如果mid大于data，则就表示插入的数据在mid的左边，high=mid-1;如果mid小于data，则就表示插入的数据在mid的右边,low=mid+1最后整体进行右移操作。时间复杂度O(n2),空间复杂度O(1)package sort.algorithm;//折半插入排序public class HalfInsertSort { public static void main(String args) { int data = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 }; // 存放临时要插入的元素数据 int temp; int low, mid, high; for (int i = 1; i 《 data.length; i++) { temp = data; // 在待插入排序的序号之前进行折半插入 low = 0; high = i - 1; while (low 《= high) { mid = (low + high) / 2; if (temp 《 data) high = mid - 1; else // low=high的时候也就是找到了要插入的位置， // 此时进入循环中，将low加1，则就是要插入的位置了 low = mid + 1; } // 找到了要插入的位置，从该位置一直到插入数据的位置之间数据向后移动 for (int j = i; j 》= low + 1; j--) data; // low已经代表了要插入的位置了 data = temp; } for (int k = 0; k 《 data.length; k++) { System.out.print(data + “ “); } }}

四 插入类排序之希尔排序希尔排序，也叫缩小增量排序，目的就是尽可能的减少交换次数，每一个组内最后都是有序的。将待续按照某一种规则分为几个子序列，不断缩小规则，最后用一个直接插入排序合成空间复杂度为O(1)，时间复杂度为O(nlog2n)算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。

package sort.algorithm;public class ShellSort { public static void main(String args) { int a = { 1, 54, 6, 3, 78, 34, 12, 45, 56, 100 }; double d1 = a.length; int temp = 0; while (true) { //利用这个在将组内倍数减小 //这里依次为5,3,2,1 d1 = Math.ceil(d1 / 2); //d为增量每个分组之间索引的增量 int d = (int) d1; //每个分组内部排序 for (int x = 0; x 《 d; x++) { //组内利用直接插入排序 for (int i = x + d; i 《 a.length; i += d) { int j = i - d; temp = a; for (; j 》= 0 && temp 《 a; j -= d) { a; } a = temp; } }

if (d == 1) break; } for (int i = 0; i 《 a.length; i++) System.out.print(a+“ “); }}五 交换类排序之冒泡排序交换类排序核心就是每次比较都要进行交换冒泡排序：是一种交换排序每一趟比较相邻的元素，较若大小不同则就会发生交换，每一趟排序都能将一个元素放到它最终的位置！每一趟就进行比较。时间复杂度O(n2)，空间复杂度O(1)package sort.algorithm;//冒泡排序：是一种交换排序public class BubbleSort { // 按照递增顺序排序 public static void main(String args) { // TODO Auto-generated method stub int data = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20, 13, 100, 37, 16 }; int temp = 0; // 排序的比较趟数,每一趟都会将剩余最大数放在最后面 for (int i = 0; i 《 data.length - 1; i++) { // 每一趟从开始进行比较，将该元素与其余的元素进行比较 for (int j = 0; j 《 data.length - 1; j++) { if (data) { temp = data; data; data = temp; } } } for (int i = 0; i 《 data.length; i++) System.out.print(data + “ “); }}

//我按着你的思路写的，自己看看吧，我运行过，结果正确public class QuickSort { public static void main(String args) { int{2,5,3,8,7,0,1,4,6,9,10}; int left = 0; int right = array.length-1; qsort(array,left,right); for(int index:array){ System.out.print(index+“ “); } } public static void qsort(int array,int left,int right){ int p; if(left《right){ p = partition(array,left,right); qsort(array,left,p-1); qsort(array,p+1,right); } } public static int partition(int arr,int left,int right){ int temp_val; int temp_r, temp_l, temp_m; temp_r = right; temp_l = left; temp_m = left; boolean flag = true; while(temp_l 《 temp_r){ if(flag){ if(arr){ temp_val = arr; arr; arr = temp_val; temp_m = temp_r; flag = false; } temp_r --; }else{ if(arr){ temp_val = arr; arr; arr = temp_val; temp_m = temp_l; flag = true; } temp_l ++; } } return temp_m; }}

初级的排序方法有泡泡,插入和选择.高级的排序方法还有堆排序,希尔排序法,快速排序法. 快速排序法（quick sort）是目前所公认最快的排序方法之一（视解题的对象而定），虽然快速排序法在最差状况下可以达O(n2)，但是在多数的情况下，快速排序法的效率表现是相当不错的。 快速排序法的基本精神是在数列中找出适当的轴心，然后将数列一分为二，分别对左边与右边数列进行排序，而影响快速排序法效率的正是轴心的选择。 1. 将最左边的数设定为轴，并记录其值为 s 循环处理： 1. 令索引 i 从数列左方往右方找，直到找到大于 s 的数 2. 令索引 j 从数列左右方往左方找，直到找到小于 s 的数 3. 如果 i 》= j，则离开循环 4. 如果 i 《 j，则交换索引i与j两处的值 5. 将左侧的轴与 j 进行交换 6. 对轴左边进行递归 7. 对轴右边进行递归 透过以下算法，则轴左边的值都会小于s，轴右边的值都会大于s，如此再对轴左右两边进行递归，就可以对完成排序的目的，例如下面的实例，*表示要交换的数， = t; }}

将数字从大到小排序的方法：

例如简一点的冒泡排序，将第一个数字和后面的数字逐个比较大小，如果小于，则互换位置，大于则不动。此时，第一个数为数组中的最大数。然后再将第二个数与后面的数逐个比较，以次类推。

示例代码如下： public class Test { public static void main(String args) { int  array = {12,3,1254,235,435,236,25,34,23}; int temp; for (int i = 0; i 《 array.length; i++) { for (int j = i+1; j 《 array.length; j++) { if (array) { temp = array; array; array = temp; // 两个数交换位置 } } } for (int i = 0; i 《 array.length; i++) { System.out.print(array+“  “); } } }

数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。

Java 语言中提供的数组是用来存储固定大小的同类型元素。

你可以声明一个数组变量，如 numbers 来代替直接声明 100 个独立变量 number0，number1，....，number99

扩展资料

Java中利用数组进行数字排序一般有4种方法：

1、选择排序是先将数组中的第一个数作为最大或最小数，然后通过循环比较交换最大数或最小数与一轮比较中第一个数位置进行排序。

2、冒泡排序也是先将数组中的第一个数作为最大或最小数，循环比较相邻两个数的大小，满足条件就互换位置，将最大数或最小数沉底。

3、快速排序法主要是运用Arrays类中的Arrays.sort方法（）实现。

4、插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。

1. 插入排序：插入排序基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入排序的基本思想是：每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

2. 选择排序：选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。

3. 冒泡排序：冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。

4. 快速排序：快速排序（Quicksort）是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

5. 归并排序：归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

6. 希尔排序：希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

你看这个链接，网页链接

希望可以帮到你，望采纳~

可以使用冒泡排序，选择排序等多种方式就行排序，两个for循环嵌套就可以或者使用sort()方法进行快速排序

快速排序法：快速排序法号称是目前最优秀的算法之一，实现思路是，将一个数组的排序问题看成是两个小数组的排序问题，而每个小的数组又可以继续看成更小的两个数组，一直递归下去，直到数组长度大小最大为2