java必會編程題之快速排序（java代碼快速排序）

本文目錄一覽：

• 1、Java程序快速排序是怎樣的，舉個例子說明一下
• 2、那位大大能詳細的講解一下JAVA中的快速排序
• 3、用JAVA實現快速排序演算法？
• 4、排序都有哪幾種方法？用JAVA實現一個快速排序。
• 5、java編程實現隨機數組的快速排序

Java程序快速排序是怎樣的，舉個例子說明一下

public class QuickSort {        

    private static void QuickSort(int[] array,int start,int end)      {              if(startend)          {              

            int key=array;//初始化保存基元               

            int i=start,j;//初始化i,j              

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

                if(array[j]key) {  //如果此處元素小於基元，則把此元素和i+1處元素交換，並將i加1，如大於或等於基元則繼續循環                                                  int temp=array[j];                      

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

                      array[i+1]=temp;                      

                      i++;                  

                }                                

           }              

           array=array[i];//交換i處元素和基元               

           array[i]=key;              

           QuickSort(array, start, i-1);//遞歸調用               

           QuickSort(array, i+1, end);                        

        }                

   }      

   public static void main(String[] args)      {          

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

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

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

           System.out.println((i+1)+”th:”+array[i]);          

       }      

   }

}

那位大大能詳細的講解一下JAVA中的快速排序

快速排序是對冒泡排序的一種改進。它的基本思想是：通過一躺排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按次方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。最壞情況的時間複雜度為O(n2)，最好情況時間複雜度為O(nlog2n)。

另外 java沒指針概念 可以認為是句柄

假設要排序的數組是A[1]……A[N]，首先任意選取一個數據（通常選用第一個數據）作為關鍵數據，然後將所有比它的數都放到它前面，所有比它大的數都放到它後面，這個過程稱為一躺快速排序。一趟快速排序的演算法是：

1）、設置兩個變數I、J，排序開始的時候I：=1，J：=N；

2）以第一個數組元素作為關鍵數據，賦值給X，即X：=A[1]；

3）、從J開始向前搜索，即由後開始向前搜索（J：=J-1），找到第一個小於X的值，兩者交換；

4）、從I開始向後搜索，即由前開始向後搜索（I：=I+1），找到第一個大於X的值，兩者交換；

5）、重複第3、4步，直到I=J；

例如：待排序的數組A的值分別是：（初始關鍵數據X：=49）

A[1] A[2] A[3] A[4] A[5] A[6] A[7]：

49 38 65 97 76 13 27

進行第一次交換後： 27 38 65 97 76 13 49

( 按照演算法的第三步從後面開始找)

進行第二次交換後： 27 38 49 97 76 13 65

( 按照演算法的第四步從前面開始找X的值，6549,兩者交換，此時I：=3 )

進行第三次交換後： 27 38 13 97 76 49 65

( 按照演算法的第五步將又一次執行演算法的第三步從後開始找)

進行第四次交換後： 27 38 13 49 76 97 65

( 按照演算法的第四步從前面開始找大於X的值，9749,兩者交換，此時J：=4 )

此時再執行第三步的時候就發現I=J，從而結束一躺快速排序，那麼經過一躺快速排序之後的結果是：27 38 13 49 76 97 65，即所以大於49的數全部在49的後面，所以小於49的數全部在49的前面。

快速排序就是遞歸調用此過程——在以49為中點分割這個數據序列，分別對前面一部分和後面一部分進行類似的快速排序，從而完成全部數據序列的快速排序，最後把此數據序列變成一個有序的序列，根據這種思想對於上述數組A的快速排序的全過程如圖6所示：

初始狀態 {49 38 65 97 76 13 27}

進行一次快速排序之後劃分為 {27 38 13} 49 {76 97 65}

分別對前後兩部分進行快速排序 {13} 27 {38}

結束 結束 {49 65} 76 {97}

49 {65} 結束

結束//下面是一個示例,哪位給說說快速排序法的原理,下面的示例中指針和上下標移動我看不太懂,

public class QuickSort {

/**主方法*/

public static void main(String[] args) {

//聲明數組

int[] nums = {27, 8, 57, 9, 23, 41, 65, 19, 0, 1, 2, 4, 5};

//應用快速排序方法

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

//顯示排序後的數組

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

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

}

System.out.println(“”);

}

/**快速排序方法*/

public static void quickSort(int[] a, int lo0, int hi0) {

int lo = lo0;

int hi = hi0;

if (lo = hi)

return;

//確定指針方向的邏輯變數

boolean transfer=true;

while (lo != hi) {

if (a[lo] a[hi]) {

//交換數字

int temp = a[lo];

a[lo] = a[hi];

a[hi] = temp;

//決定下標移動，還是上標移動

transfer = (transfer == true) ? false : true;

}

//將指針向前或者向後移動

if(transfer)

hi–;

else

lo++;

//顯示每一次指針移動的數組數字的變化

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

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

}

System.out.print(” (lo,hi) = ” + “(” + lo + “,” + hi + “)”);

System.out.println(“”);*/

}

//將數組分開兩半，確定每個數字的正確位置

lo–;

hi++;

quickSort(a, lo0, lo);

quickSort(a, hi, hi0);

}

}

用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實現一個快速排序。

排序的方法有：插入排序（直接插入排序、希爾排序），交換排序（冒泡排序、快速排序），選擇排序（直接選擇排序、堆排序），歸併排序，分配排序（箱排序、基數排序）

快速排序的偽代碼。

/ /使用快速排序方法對a[ 0 :n- 1 ]排序

從a[ 0 :n- 1 ]中選擇一個元素作為m i d d l e，該元素為支點

把餘下的元素分割為兩段left 和r i g h t，使得l e f t中的元素都小於等於支點，而right 中的元素都大於等於支點

遞歸地使用快速排序方法對left 進行排序

遞歸地使用快速排序方法對right 進行排序

所得結果為l e f t + m i d d l e + r i g h t

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] + ” “);

        }

    }

}