急啊!求一段关于java 的快速排序的代码

public class quickSort {

创新互联公司主要从事成都网站建设、网站建设、网页设计、企业做网站、公司建网站等业务。立足成都服务钦北,十余年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:13518219792

public quickSort() {

}

public void printA(int[] a) {

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

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

}

System.out.println();

}

public void chooseSort(int[] a, int left, int right) {

int smallest;

int flagIndex = 0;

int forSwap;

boolean flag;

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

smallest = a[i];

// System.out.println("first" + smallest);

flagIndex = i;

flag = false;

for (int j = i + 1; j = right; j++) {

if (a[j] smallest) {

smallest = a[j];

flagIndex = j;

flag = true;

// System.out.println(smallest + " " + flagIndex);

}

}

if(flag){

forSwap = a[i];

a[i] = smallest;

a[flagIndex] = forSwap;

// System.out.println(smallest);

// printA(a);

// printA(a);

}

}

}

public void quickSort(int[] a, int left, int right) {

int index;

// printA(a);

if (left right right - left 10) { //可以优化如果数组元素小于10就用选择排序

index = partition(a, left, right);

quickSort(a, left, index - 1);

quickSort(a, index + 1, right);

} else {

chooseSort(a, left, right);

}

}

public int partition(int[] a, int left, int right) {

int result = getMiddle(a[left], a[right], a[(int) ((left + right) / 2)]);

int flagIndex;

if (result == 1) {

flagIndex = left;

} else if (result == 2) {

flagIndex = right;

} else {

flagIndex = (int) ((left + right) / 2);

}

int lowIndex, highIndex;

lowIndex = left - 1;

highIndex = right + 1;

int compareValue = a[flagIndex];

int k = a[left];

a[left] = compareValue;

a[flagIndex] = k;

// System.out.println(compareValue);

while (lowIndex + 1 != highIndex) {

if (a[lowIndex + 1] = compareValue) {

lowIndex++;

} else if (a[highIndex - 1] = compareValue) {

highIndex--;

} else {

k = a[lowIndex + 1];

a[++lowIndex] = a[highIndex - 1];

a[--highIndex] = k;

}

}

// printA(a);

a[left] = a[lowIndex];

a[lowIndex] = compareValue;

return lowIndex;

}

public int getMiddle(int a, int b, int c) {

if (a = b) {

if (b = c) {

return 2;

} else {

if (a = c) {

return 3;

} else {

return 1;

}

}

} else {

if (c = b) {

return 2;

} else {

if (a = c) {

return 1;

} else {

return 3;

}

}

}

// return 0;

}

}

java编程实现随机数组的快速排序

java编程实现随机数组的快速排序步骤如下：

1、打开Eclipse，新建一个Java工程，在此工程里新建一个Java类；

2、在新建的类中声明一个产生随机数的Random变量，再声明一个10个长度的int型数组；

3、将产生的随机数逐个放入到数组中；

4、利用排序算法对随机数组进行排序。

具体代码如下：

import java.util.Random;

public class Demo {

public static void main(String[] args) {

int count = 0;

Random random = new Random();

int a[] = new int[10];

while(count  10){

a[count] = random.nextInt(1000);//产生0-999的随机数

count++;

}

for (int i = 0; i  a.length - 1; i++) {

int min = i;

for (int j = i + 1; j  a.length; j++) {

if (a[j]  a[min]) {

min = j;

}

}

if (min != i) {

int b = a[min];

a[min] = a[i];

a[i] = b;

}

}

for (int c = 0; c  a.length; c++) {

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

}

}

}

请问一下java快速排序源代码

快速排序：

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**

* @author treeroot

* @since 2006-2-2

* @version 1.0

*/

public class QuickSort implements SortUtil.Sort{

/* (non-Javadoc)

* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

public void sort(int[] data) {

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

}

private void quickSort(int[] data,int i,int j){

int pivotIndex=(i+j)/2;

//swap

SortUtil.swap(data,pivotIndex,j);

int k=partition(data,i-1,j,data[j]);

SortUtil.swap(data,k,j);

if((k-i)1) quickSort(data,i,k-1);

if((j-k)1) quickSort(data,k+1,j);

}

/**

* @param data

* @param i

* @param j

* @return

*/

private int partition(int[] data, int l, int r,int pivot) {

do{

while(data[++l]pivot);

while((r!=0)data[--r]pivot);

SortUtil.swap(data,l,r);

}

while(lr);

SortUtil.swap(data,l,r);

return l;

}

}

改进后的快速排序：

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**

* @author treeroot

* @since 2006-2-2

* @version 1.0

*/

public class ImprovedQuickSort implements SortUtil.Sort {

private static int MAX_STACK_SIZE=4096;

private static int THRESHOLD=10;

/* (non-Javadoc)

* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

public void sort(int[] data) {

int[] stack=new int[MAX_STACK_SIZE];

int top=-1;

int pivot;

int pivotIndex,l,r;

stack[++top]=0;

stack[++top]=data.length-1;

while(top0){

int j=stack[top--];

int i=stack[top--];

pivotIndex=(i+j)/2;

pivot=data[pivotIndex];

SortUtil.swap(data,pivotIndex,j);

//partition

l=i-1;

r=j;

do{

while(data[++l]pivot);

while((r!=0)(data[--r]pivot));

SortUtil.swap(data,l,r);

}

while(lr);

SortUtil.swap(data,l,r);

SortUtil.swap(data,l,j);

if((l-i)THRESHOLD){

stack[++top]=i;

stack[++top]=l-1;

}

if((j-l)THRESHOLD){

stack[++top]=l+1;

stack[++top]=j;

}

}

//new InsertSort().sort(data);

insertSort(data);

}

/**

* @param data

*/

private void insertSort(int[] data) {

int temp;

for(int i=1;idata.length;i++){

for(int j=i;(j0)(data[j]data[j-1]);j--){

SortUtil.swap(data,j,j-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快速排序的正确代码

一趟快速怕序的具体做法是：附设两个指针low和high,他们的初值分别为low和high,设枢轴记录的关键字为privotkey,则首先从high所指位置向前搜索找到第一个关键字小于pivotkey的记录和枢轴记录互相交换,然后从low所指向的位置起向后搜索,找到第一个关键字大于privotkey的记录和枢轴记录互相交换，重复这两步直至low==high位置.

import java.util.concurrent.Executor;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class 快速排序_1 {

public static void main(String[] args) throws InterruptedException {

int test[] = {15,23,56,7,13,52,20,7};

new 快速排序_1().qSort(test, 0, test.length-1);

for(int k:test) System.out.println(k);

}

public void qSort(int []array,int low,int high){

if(low

int privot=partition(array,low,high);

qSort(array,low,privot-1);

qSort(array,privot+1,high);

}

}

public int partition(int [] array,int low,int high){

/**

* 选择 low位置 作为曲轴(支点)

*/

int pivot=array[low];

int temp=0;

/**

* 如果 low

*/

while(low

/**

* 先从 high端 开始判断

*/

while(low=pivot) high--;

/**

* 进行 置换操作

*/

if(low

array[low]=array[high];

low++;

}

/**

* 从 low 端判断

*/

while(low

/**

* 进行 置换操作

*/

if(low

array[high]=array[low];

high--;

}

}

array[low]=pivot;

return low;

}

}

java快速排序代码中SwapReferences（）方法是什么？代码怎么写？

/**

 * 快速排序

 */

private static void quickSort ( int[] array, int start, int end )

{

if (start  end)

{

int key = array;

int i = start;

for ( int j = start + 1; j  end + 1; j++ )

{

if (key  array[j])

{

int temp = array[j];

array[j] = array[i + 1];

array[i + 1] = temp;

i++;

}

}

array = array[i];

array[i] = key;

quickSort (array, start, i - 1);

quickSort (array, i + 1, end);

}

}

int[] array = new int[] { 11, 213, 134, 65, 77, 78, 23, 43 };

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

System.out.println (Arrays.toString (array));

新闻标题：java快速排序经典代码,java快速排序简单代码
本文网址：http://azwzsj.com/article/dsssgsi.html