快速排序java,快速排序javascript

本文目录一览：

• 1、如何用JAVA实现快速排序算法？
• 2、举一个简单java快速排序的例子？
• 3、请问一下java快速排序源代码
• 4、Java的几种常见排序
• 5、java快速排序问题

如何用JAVA实现快速排序算法？

本人特地给你编的代码\x0d\x0a亲测\x0d\x0a\x0d\x0apublicclassQuickSort{\x0d\x0a\x0d\x0apublicstaticintPartition(inta[],intp,intr){\x0d\x0aintx=a[r-1];\x0d\x0ainti=p-1;\x0d\x0ainttemp;\x0d\x0afor(intj=p;jif(a[j-1]//swap(a[j-1],a[i-1]);\x0d\x0ai++;\x0d\x0atemp=a[j-1];\x0d\x0aa[j-1]=a[i-1];\x0d\x0aa[i-1]=temp;\x0d\x0a\x0d\x0a}\x0d\x0a}\x0d\x0a//swap(a[r-1,a[i+1-1]);\x0d\x0atemp=a[r-1];\x0d\x0aa[r-1]=a[i+1-1];\x0d\x0aa[i+1-1]=temp;\x0d\x0a\x0d\x0areturni+1;\x0d\x0a\x0d\x0a}\x0d\x0a\x0d\x0apublicstaticvoidQuickSort(inta[],intp,intr){\x0d\x0a\x0d\x0aif(p

举一个简单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快速排序源代码

快速排序：

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的几种常见排序

快速排序法、冒泡法、选择排序法、插入排序法

1.快速排序：

import java.util.Arrays;

public class Test2{

public static void main(String[] args){

int[] a={5,4,2,4,9,1};

Arrays.sort(a); //进行排序

for(int i: a){

System.out.print(i);

}

}

}

2.冒泡排序

public static int[] bubbleSort(int[] args){//冒泡排序算法

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

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

if (args[i]args[j]){

int temp=args[i];

args[i]=args[j];

args[j]=temp;

}

}

}

return args;

}

3.选择排序

public static int[] selectSort(int[] args){//选择排序算法

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

int min=i;

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

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

min=j;

}

}

if (min!=i){

int temp=args[i];

args[i]=args[min];

args[min]=temp;

}

}

return args;

}

4.插入排序

public static int[] insertSort(int[] args){//插入排序算法

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

for(int j=i;j0;j–){

if (args[j]args[j-1]){

int temp=args[j-1];

args[j-1]=args[j];

args[j]=temp;

}else break;

}

}

return args;

}

java快速排序问题

帮你改了一下：

public class Point{

public static void main(String[] args) {

int[] a = {4,63,2,4,4,6,43,2,3};

quickSort(a, 0, a.length – 1);

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

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

}

}

static int Partition(int[] a, int left, int right)

{

int tmp;

//进行一趟快速排序,返回中心记录位置

int pivot = a[left];//把中心置于a[0]

while (left right)

{

while(leftright a[right]=pivot)

right–;

//将比中心记录小的移到低端

tmp = a[right];

a[right] = a[left];

a[left] = tmp;

while(leftright a[left]=pivot)

left++;

tmp = a[right];

a[right] = a[left];

a[left] = tmp;

//将比中心记录大的移到高端

}

a[left] = pivot; //中心移到正确位置

return left; //返回中心位置

}

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

if(left = right – 1)

return;

int pivot = Partition(a,left,right);

quickSort(a, left, pivot-1);

quickSort(a, pivot+1, right);

}

}