求使用java实现的快排算法

① 代码：

目前创新互联公司已为上1000家的企业提供了网站建设、域名、网络空间、绵阳服务器托管、企业网站设计、宣恩网站维护等服务，公司将坚持客户导向、应用为本的策略，正道将秉承"和谐、参与、激情"的文化，与客户和合作伙伴齐心协力一起成长，共同发展。

public class quicksortdemo {

private int array[];

private int length;

public void sort(int[] inputArr) {

if (inputArr == null || inputArr.length == 0) {

return;

}

this.array = inputArr;

length = inputArr.length;

quickSort(0, length - 1);

}

private void quickSort(int lowerIndex, int higherIndex) {

int i = lowerIndex;

int j = higherIndex;

// calculate pivot number

int pivot = array[lowerIndex+(higherIndex-lowerIndex)/2];

// Divide into two arrays

while (i = j) {

while (array[i]  pivot) {

i++;

}

while (array[j]  pivot) {

j--;

}

if (i = j) {

swap(i, j);                

i++;

j--;

}

}

// call quickSort() method recursively

if (lowerIndex  j)

quickSort(lowerIndex, j);

if (i  higherIndex)

quickSort(i, higherIndex);

}

private void swap(int i, int j) {

int temp = array[i];

array[i] = array[j];

array[j] = temp;

}

public static void main(String a[]){

quicksortdemo sorter = new quicksortdemo();

int[] input = {24,2,45,20,56,75,2,56,99,53,12};

sorter.sort(input);

for(int i:input){

System.out.print(i);

System.out.print(" ");

}

}

}

② 运行：

c:\java quicksortdemo

2 2 12 20 24 45 53 56 56 75 99

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快速排序源代码

快速排序：

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快速排序的例子？

Java中的快速排序一个简单的例子

public class QuickSort {

public static void sort(Comparable[] data, int low, int high) {

// 枢纽元,一般以第一个元素为基准进行划分

Comparable pivotKey = data[low];

// 进行扫描的指针i,j;i从左边开始,j从右边开始

int i = low;

int j = high;

if (low high) {

// 从数组两端交替地向中间扫描

while (i j) {

while (i j data[j].compareTo(pivotKey) 0) {

j--; }

// end while

if (i j) {

// 比枢纽元素小的移动到左边

data[i] = data[j];

i++;

}

// end if

while (i j data[i].compareTo(pivotKey) 0) {

i++;

}

// end while

if (i j) {

// 比枢纽元素大的移动到右边

data[j] = data[i];

j--;

}

// end if

}

// end while

// 枢纽元素移动到正确位置

data[i] = 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 high

QuickSort qs = new QuickSort（）；

qs.sort（[] data, low, high）；

分享文章：快速排序JAVA代码分析,快速排序java代码分析方法
文章出自：http://chengdu.cdxwcx.cn/article/dseoeej.html