「java排序快速排序」java快速排序的两种方法

今天给各位分享java排序快速排序的知识，其中也会对java快速排序的两种方法进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、java快速排序
• 2、那位大大能详细的讲解一下JAVA中的快速排序
• 3、Java快速排序
• 4、用JAVA实现快速排序算法？
• 5、如何用java实现快速排序，简答讲解下原理

java快速排序

public class demo11 {

public static void main(String[] args) {

// TODO Auto-generated method stub

QuickSort quick = new QuickSort();

int arr[] = { 4, 2, 6, 1, 5, 0, 8, -1 };

quick.Sort(arr, 0, arr.length-1);

for(int i:arr)

System.out.println(i);

}

}

class QuickSort {

public void Sort(int arr[], int left, int right) {

if(left == right) return;

System.out.println("sort:");

for(int i=left;i=right;i++)

{

System.out.print(arr[i]+" ");

}

System.out.println("");

int inser = arr[left];

int temp;

int le = left;

int re = right ;

while (le re) {

while (le re inser arr[re]) {

re--;

}

if(re==le) break;

temp = arr[re];

arr[re] = arr[le];

arr[le] = temp;

le++;

while (le re inser arr[le]) {

le++;

}

if(re==le) break;

temp = arr[re];

arr[re] = arr[le];

arr[le] = temp;

re--;

}

arr[le]=inser;

if(leleft)

Sort(arr, left, le-1);

if(reright)

Sort(arr,le+1,right);

}

}

排序的思路是：取数组的第一个数(arr[left])为参考值(inser),将比参考值(inser)小的数全部放到参考值左边，比参考值(inser)大的全部放到参考值右边。然后用相同的方法对参考值右边和左边的数组进行排序。

那位大大能详细的讲解一下JAVA中的快速排序

快速排序是对冒泡排序的一种改进。它的基本思想是：通过一躺排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按次方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。最坏情况的时间复杂度为O(n2)，最好情况时间复杂度为O(nlog2n)。

另外 java没指针概念 可以认为是句柄

假设要排序的数组是A[1]……A[N]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一躺快速排序。一趟快速排序的算法是：

1）、设置两个变量I、J，排序开始的时候I：=1，J：=N；

2）以第一个数组元素作为关键数据，赋值给X，即X：=A[1]；

3）、从J开始向前搜索，即由后开始向前搜索（J：=J-1），找到第一个小于X的值，两者交换；

4）、从I开始向后搜索，即由前开始向后搜索（I：=I+1），找到第一个大于X的值，两者交换；

5）、重复第3、4步，直到I=J；

例如：待排序的数组A的值分别是：（初始关键数据X：=49）

A[1] A[2] A[3] A[4] A[5] A[6] A[7]：

49 38 65 97 76 13 27

进行第一次交换后： 27 38 65 97 76 13 49

( 按照算法的第三步从后面开始找)

进行第二次交换后： 27 38 49 97 76 13 65

( 按照算法的第四步从前面开始找X的值，6549,两者交换，此时I：=3 )

进行第三次交换后： 27 38 13 97 76 49 65

( 按照算法的第五步将又一次执行算法的第三步从后开始找)

进行第四次交换后： 27 38 13 49 76 97 65

( 按照算法的第四步从前面开始找大于X的值，9749,两者交换，此时J：=4 )

此时再执行第三步的时候就发现I=J，从而结束一躺快速排序，那么经过一躺快速排序之后的结果是：27 38 13 49 76 97 65，即所以大于49的数全部在49的后面，所以小于49的数全部在49的前面。

快速排序就是递归调用此过程——在以49为中点分割这个数据序列，分别对前面一部分和后面一部分进行类似的快速排序，从而完成全部数据序列的快速排序，最后把此数据序列变成一个有序的序列，根据这种思想对于上述数组A的快速排序的全过程如图6所示：

初始状态 {49 38 65 97 76 13 27}

进行一次快速排序之后划分为 {27 38 13} 49 {76 97 65}

分别对前后两部分进行快速排序 {13} 27 {38}

结束 结束 {49 65} 76 {97}

49 {65} 结束

结束//下面是一个示例,哪位给说说快速排序法的原理,下面的示例中指针和上下标移动我看不太懂,

public class QuickSort {

/**主方法*/

public static void main(String[] args) {

//声明数组

int[] nums = {27, 8, 57, 9, 23, 41, 65, 19, 0, 1, 2, 4, 5};

//应用快速排序方法

quickSort(nums, 0, nums.length-1);

//显示排序后的数组

for(int i = 0; i nums.length; ++i) {

System.out.print(nums[i] + ",");

}

System.out.println("");

}

/**快速排序方法*/

public static void quickSort(int[] a, int lo0, int hi0) {

int lo = lo0;

int hi = hi0;

if (lo = hi)

return;

//确定指针方向的逻辑变量

boolean transfer=true;

while (lo != hi) {

if (a[lo] a[hi]) {

//交换数字

int temp = a[lo];

a[lo] = a[hi];

a[hi] = temp;

//决定下标移动，还是上标移动

transfer = (transfer == true) ? false : true;

}

//将指针向前或者向后移动

if(transfer)

hi--;

else

lo++;

//显示每一次指针移动的数组数字的变化

/*for(int i = 0; i a.length; ++i) {

System.out.print(a[i] + ",");

}

System.out.print(" (lo,hi) = " + "(" + lo + "," + hi + ")");

System.out.println("");*/

}

//将数组分开两半，确定每个数字的正确位置

lo--;

hi++;

quickSort(a, lo0, lo);

quickSort(a, hi, hi0);

}

}

Java快速排序

原理：

快速排序也是分治法思想的一种实现，他的思路是使数组中的每个元素与基准值（Pivot，通常是数组的首个值，A[0]）比较，数组中比基准值小的放在基准值的左边，形成左部；大的放在右边，形成右部；接下来将左部和右部分别递归地执行上面的过程：选基准值，小的放在左边，大的放在右边。。。直到排序结束。

步骤：

1.找基准值，设Pivot = a[0]

2.分区（Partition）：比基准值小的放左边，大的放右边，基准值(Pivot)放左部与右部的之间。

3.进行左部（a[0] - a[pivot-1]）的递归，以及右部（a[pivot+1] - a[n-1]）的递归，重复上述步骤

用JAVA实现快速排序算法？

本人特地给你编的代码

亲测

public class QuickSort {

public static int Partition(int a[],int p,int r){

int x=a[r-1];

int i=p-1;

int temp;

for(int j=p;j=r-1;j++){

if(a[j-1]=x){

// swap(a[j-1],a[i-1]);

i++;

temp=a[j-1];

a[j-1]=a[i-1];

a[i-1]=temp;

}

}

//swap(a[r-1,a[i+1-1]);

temp=a[r-1];

a[r-1]=a[i+1-1];

a[i+1-1]=temp;

return i+1;

}

public static void QuickSort(int a[],int p,int r){

if(pr){

int q=Partition(a,p,r);

QuickSort(a,p,q-1);

QuickSort(a,q+1,r);

}

}

public static void main(String[] stra){

int a[]={23,53,77,36,84,76,93,13,45,23};

QuickSort(a,1,10);

for (int i=1;i=10;i++)

System.out.println(a[i-1]);

}

}

如何用java实现快速排序，简答讲解下原理

快速排序思想：

通过对数据元素集合Rn 进行一趟排序划分出独立的两个部分。其中一个部分的关键字比另一部分的关键字小。然后再分别对两个部分的关键字进行一趟排序，直到独立的元素只有一个，此时整个元素集合有序。

快速排序的过程，对一个元素集合R[ low ... high ] ,首先取一个数（一般是R[low] ）做参照 ， 以R[low]为基准重新排列所有的元素。

所有比R[low]小的放前面，所有比R[low] 大的放后面，然后以R[low]为分界，对R[low ... high] 划分为两个子集和，再做划分。直到low = high 。

比如：对R={37, 40, 38, 42, 461, 5, 7, 9, 12}进行一趟快速排序的过程如下(注:下面描述的内容中元素下表从 0 开始)：

开始选取基准 base = 37，初始位置下表 low = 0 ， high = 8 ， 从high=8，开始如果R[8] base , 将high位置中的内容写入到R[low]中, 将high位置空出来, low = low +1 ;

从low开始探测，由于low=1 ， R[low] base ,所以将R[low]写入到R[high] , high = high -1 ;

检测到low high ,所以第一趟快速排序仍需继续:

此时low=1，high=7，因为 R[high] base ,所以将 R[high] 写入到到R[low]中,low = low + 1;

从low开始探测,low = 2 , R[low] base ,所以讲R[low]写入到R[high]，high=high-1;

继续检测到 low 小于high

此时low=2，high=6，同理R[high] base ,将R[high] 写入到R[low]中，low=low+1;

从low继续探测,low = 3 , high=6 , R[low] base , 将R[low]写入到R[high]中，high = high-1;

继续探测到low小于high

此时low=3，high=5，同理R[high] base,将R[high]写入到R[low]中，low = low +1；

从low继续探测，low = 4，high=5，由于R[low] base , 将R[low]写入到R[high]中，high = high -1 ;

此时探测到low == high == 4 ；该位置即是base所在的位置，将base写入到该位置中.

然后再对子序列Rs1 = {12,9,7,5} 和 Rs2={461,42,38,40}做一趟快速排序，直到Rsi中只有一个元素，或没有元素。

快速排序的Java实现：

private static boolean isEmpty(int[] n) {

return n == null || n.length == 0;

}

// ///////////////////////////////////////////////////

/**

* 快速排序算法思想——挖坑填数方法：

*

* @param n 待排序的数组

*/

public static void quickSort(int[] n) {

if (isEmpty(n))

return;

quickSort(n, 0, n.length - 1);

}

public static void quickSort(int[] n, int l, int h) {

if (isEmpty(n))

return;

if (l h) {

int pivot = partion(n, l, h);

quickSort(n, l, pivot - 1);

quickSort(n, pivot + 1, h);

}

}

private static int partion(int[] n, int start, int end) {

int tmp = n

今天给各位分享java排序快速排序的知识，其中也会对java快速排序的两种方法进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

;

while (start end) {

while (n

关于java排序快速排序和java快速排序的两种方法的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。

= tmp start end)

end--;

if (start end) {

n[start++] = n

关于java排序快速排序和java快速排序的两种方法的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。

;

}

while (n

今天给各位分享java排序快速排序的知识，其中也会对java快速排序的两种方法进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

tmp start end)

start++;

if (start end) {

n[end--] = n

今天给各位分享java排序快速排序的知识，其中也会对java快速排序的两种方法进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

;

}

}

n

今天给各位分享java排序快速排序的知识，其中也会对java快速排序的两种方法进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

= tmp;

return start;

}

在代码中有这样一个函数：

public static void quickSortSwap(int[] n, int l, int h)

该函数可以实现，元素集合中特定的 l 到 h 位置间的数据元素进行排序。

关于java排序快速排序和java快速排序的两种方法的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。