A. 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(le>left)
Sort(arr, left, le-1);
if(re<right)
Sort(arr,le+1,right);
}
}

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

B. 用JAVA实现一个快速排序

不知道你给的是一组什么数。
给你个思路，很简单。通过toCharArray()方法将字符串转换成数组
然后通过Array.sort();排序就可以了

C. java中快速排序的算法举个例子

package person.test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Random;

/**
* class name: RapidSort
* description: Java快速排序法：数组和集合
* @author Jr
*
*/
public class RapidSort {
private Random ran = new Random(); // 声明一个全局变量ran，用来随机生成整数

/**
* method name: sortArray
* description: 对数组的快速排序，只能用于int[]类型的数组
* @return
*/
private void sortArray() {
int[] array = new int[10]; // 声明数组长度为10
for (int i = 0 ; i < array.length; i++) {
array[i] = ran.nextInt(10) + 1; // 数组赋值
}
Arrays.sort(array);
System.out.println(Arrays.toString(array));
}

/**
* method name: sortList
* description: 对集合的快速排序，可以用于List<Object>类型数组，
* 隐含意思就是对所有类型数组都适用
* @return
*/
private void sortList() {
List<Integer> list = new ArrayList<Integer>();
for (int i = 0 ; i < 10; i++) {
list.add(ran.nextInt(10) + 1); // 给集合赋10个值
}
Collections.sort(list);
System.out.println(list);
}

public static void main(String[] args) {
RapidSort rs = new RapidSort();
rs.sortArray();
rs.sortList();
}
}

D. 排序都有哪几种方法用JAVA实现一个快速排序。

前置 后置 冒泡
int mp[] = new int[1,2,12,22,58,48,0];

for (int i = 0; i < mp.length; i++) {
for (int j = 0; j < mp.length; j++) {
int temp;
if (mp[i] < mp[j]) {
temp = mp[j];
mp[j] = mp[i];
mp[i] = temp;
}
}
}
for (int i = 0; i < mp.length; i++) {
System.out.print(mp[i] + " ");
}
System.out.print("\n");

E. Java 快速排序法的实例!

package quickSort;

import java.util.Arrays;

/**
*
*
* 快速排序的思想：分区法+挖坑填数法。
* 1、先从数列中取出一个数作为枢纽关键字，一般用第一个元素
* 2、分区过程，将比这个枢纽关键字大的数全放在它的右边，把小于或者等于的数全放在它左边
* 3、再对左右分区进行第二步的操作，也就是递归。知道各个区间只有一个数为止
*
* 快速排序是冒泡排序的一种改进，有很多快速排序的方法还是用每次在比较后都用冒泡排序
* 的方式交换，但是这样的效率要比只用一个枢纽关键字来控制交换的效率要大，所以下面是一种改进
*/
public class QuickSort {
public static void main(String args[])
{
int array[]={49,38,65,97,76,13,27,49};
System.out.println(Arrays.toString(array));
quickSort(array,0,array.length-1);
System.out.println(Arrays.toString(array));
}
/**
* 分区方法：负责每次递归执行未分区的数据，也就是每次分区后枢纽关键字左右两边的元素
* @param arr 要排序的数组
* @param low 数组中小的索引，用于向后扫描
* @param high 数组中大的索引，用于向前扫描
*/
public static void quickSort(int arr[],int low,int high)
{
if(low<high)
{
int mid = partition(arr,low,high);
//对枢纽关键字左边的分区进行分区
quickSort(arr,low,mid-1);
//对枢纽关键字右边的分区进行分区
quickSort(arr,mid+1,high);
}
}
/**
* 挖坑填数，即具体实现分区的方法，每次的结果是将数组分为比枢纽关键字小的在左边，
* 比枢纽关键字大的在右边
* @param array 要排序的数组
* @param low
* @param high
* @return 执行完分区后low的坐标值，用于下次递归的时候分区用
*/
public static int partition(int array[],int low,int high)
{
//将数组中第一个元素作为枢纽关键字，这个关键字将在本次分区过程中不变
int pivotKey = array[low];
int i=low,j=high;

if(low<high)
{
while(i<j)
{
//从后向前扫描，如果array[j]>=pivotKey，则下表j向前移动
while(i<j&&array[j]>=pivotKey)
{
j--;
}
//array[j]<pivotKey，则将array[j]挖出来填入array[i]，即刚才被pivotKey挖走的地方
if(i<j)
{
array[i]=array[j];
i++;
}

//如果array[i]<=pivotKey，则下表i向后移动
while(i<j&&array[i]<=pivotKey)
{
i++;
}
//arry[i]>pivotKey，将array[i]挖出来填入刚才被挖的array[j]
if(i<j)
{
array[j]=array[i];
j--;
}
}
//如果到最后i=j的时候，也就是扫描完整个数组，则将枢纽关键字填入剩下的那个被挖的坑array[i]
array[i]=pivotKey;

}
//打印每次分区后的结果
System.out.println(Arrays.toString(array));
//将这个分区结束时的坐标i返回，用于下次执行时当做前分区的尾坐标，当做后分区的头坐标
return i;
}
}

F. 用java快速排序法,求十个数中的最大值

publicclassQuickSort{
privateint[]list={};

publicvoidsetList(int[]list){
this.list=list;
}

publicint[]getList(){
returnthis.list;
}

publicvoidsort(intleft,intright){
if(left>right)return;
inti=left;
intj=right;
inttmp=list[left];
intt;
while(i!=j){
while(list[j]>=tmp&&i<j)j--;
while(list[i]<=tmp&&i<j)i++;

if(i<j){
t=list[i];
list[i]=list[j];
list[j]=t;
}
}

list[left]=list[i];
list[i]=tmp;
sort(left,i-1);
sort(i+1,right);
}
}

G. Java快速排序

原理：
快速排序也是分治法思想的一种实现，他的思路是使数组中的每个内元素与基准值（Pivot，通常是容数组的首个值，A[0]）比较，数组中比基准值小的放在基准值的左边，形成左部；大的放在右边，形成右部；接下来将左部和右部分别递归地执行上面的过程：选基准值，小的放在左边，大的放在右边。。。直到排序结束。
步骤：
1.找基准值，设Pivot = a[0]
2.分区（Partition）：比基准值小的放左边，大的放右边，基准值(Pivot)放左部与右部的之间。
3.进行左部（a[0] - a[pivot-1]）的递归，以及右部（a[pivot+1] - a[n-1]）的递归，重复上述步骤

H. 怎么用java实现快速排序

package com.xinhua.test2;
public class Student {
int sno;
String name;
double chiness;
double math;
double english;
double three_sco;
double all_s;
public Student(int sno, String name, double chiness, double math, double english, double three_sco) {
this.sno = sno;
this.name = name;
this.chiness = chiness;
this.math = math;
this.english = english;
this.three_sco = three_sco;
}
@Override
public String toString() {
return "学号：" + sno + ", 名字：" + name + ", 语文成绩：" + chiness + ", 数学成绩：" + math + ", 英语成绩："
+ english + "总成绩："+(chiness+math+english+three_sco);
}
public static void main(String[] args) {
Student A=new Student(1, "张三", 118, 145, 114.5, 198);
Student B=new Student(2, "李四", 130,110.5,100,210);
Student C=new Student(3, "王五",142.5,120,87.5,245.5);
System.out.println("学生列表信息为：");
System.out.println(A.toString());
System.out.println(B.toString());
System.out.println(C.toString());
//
double a_scoAll=A.chiness+A.math+A.english+A.three_sco;
A.all_s=a_scoAll;
double b_scoAll=B.chiness+B.math+B.english+B.three_sco;
B.all_s=b_scoAll;
double c_sclAll=C.chiness+C.math+C.english+C.three_sco;
C.all_s=c_sclAll;
Student[] s_s={A,B,C};
System.out.println("按总成绩从大到小排序为");
Student temp;
for(int i=0;i<s_s.length;i++){
for(int j=1;j<s_s.length-i;j++){
if(s_s[j-1].all_s < s_s[j].all_s){
temp=s_s[j-1] ;
s_s[j-1] =s_s[j];
s_s[j]=temp;
}
}
}
for(int i=0;i<s_s.length;i++){
System.out.println("第"+(i+1)+"名为："+s_s[i].toString());
}
}
}