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());
}
}
}