2.8.1題目描述

使用圖形化介面的方式，顯示快速排序和歸併排序的效果。

2.8.2程式使用說明

Java version: 1.8.0_111

IDE:eclipse

歸併排序演示，Eclipse開啟MergeSortDemonstration.java檔案，右鍵run，出現圖形化介面，演示自動進行。

快速排序演示，同上，執行QuickSortDemonstration.java檔案

2.8.3簡要分析和設計

歸併排序分析：

  實現歸併排序的另一種方式是從小陣列開始歸併：首先我們將陣列的每一個元素都當做一個只有一個元素的陣列，然後將其兩兩歸併。然後我們將整個陣列的每兩個元素都當做一個小陣列，然後將其兩兩歸併，然後四個四個歸併，依次類推，直到最後歸併成一個大陣列，排序就完成了。如下是歸併排序的演示圖：

 

（圖片來源於http://www.cnblogs.com/jingmoxukong/p/4308823.html）

歸併排序虛擬碼：

MERGE SORT(A, p, r)        //對A[p..r]進行歸併排序

              if  p < r

                then q ← (p+r)/2    //將A[p..r]分成兩個子序列進行遞迴歸併排序

                     MERGE-SORT (A, p, q)

                     MERGE-SORT (A, q+1, r)

                     MERGE (A, p, q, r)              

  MERGE(A, p, q, r)

              n1 ← q-p+1;   //計算左半部分已排序序列的長度

             n2 2 ← r-q;    //計算右半部分已排序序列的長度

             create arrays L[1..n1+1] and R[1..n2+1]      

             for i ← 1 to n1

                  do L[i] ← A[p + i-1]  //copy左半部分已排序序列到L中

             for j ← 1 to n2

                  do R[j] ← A[q + j]  //copy右半部分已排序序列

  L[n1+1] ←∞                                                              

              R[n2+1] ← ∞

             i ← 1

             j ← 1

             for k ← p to r      //進行合併

                  do if L[i] < R[j]

                      then A[k] ← L[i]

                              i ← i + 1

                     else A[k] ← R[j]

                             j ← j + 1

歸併排序複雜度：O(n log n)

快速排序分析：

設要排序的陣列是A[0]……A[N-1]，首先任意選取一個數據（通常選用陣列的第一個數）作為關鍵資料，然後將所有比它小的數都放到它前面，所有比它大的數都放到它後面，這個過程稱為一趟快速排序。

一趟快速排序的演算法是：

1）設定兩個變數i、j，排序開始的時候：i=0，j=N-1；

2）以第一個陣列元素作為關鍵資料，賦值給key，即key=A[0]；

3）從j開始向前搜尋，即由後開始向前搜尋(j--)，找到第一個小於key的值A[j]，將A[j]和A[i]互換；

4）從i開始向後搜尋，即由前開始向後搜尋(i++)，找到第一個大於key的A[i]，將A[i]和A[j]互換；

5）重複第3、4步，直到i=j； (3,4步中，沒找到符合條件的值，即3中A[j]不小於key,4中A[i]不大於key的時候改變j、i的值，使得j=j-1，i=i+1，直至找到為止。找到符合條件的值，進行交換的時候i， j指標位置不變。

快速排序虛擬碼：

quicksort(A, lo, hi)

   if lo < hi

     p = partition(A, lo, hi)

     quicksort(A, lo, p - 1)

     quicksort(A, p + 1, hi)

 partition(A, lo, hi)

     pivot = A[hi]

     i = lo

     for j = lo to hi - 1

         if A[j] <= pivot

             swap A[i] with A[j]

 i = i + 1

     swap A[i] with A[hi]

     return i

快速排序時間複雜度：O（nlogn）

2.8.4測試用例

歸併排序測試用例：

{6,3,19,40,45,30,33,35,34,23,18,27,39,14,17,31,36}

執行結果：

快速排序執行結果：

 

2.8.5原始碼

 結構圖：

package four.four;

import java.awt.Color;

import java.awt.Graphics;

import javax.swing.JFrame;

import javax.swing.JPanel;

/**

 * 歸併排序的演示系統

 * @author ym

 *

 */

public class MergeSortDemonstration  extends JPanel{

/**

 * 序列號

 */

private static final long serialVersionUID = 1L;

//陣列，儲存動畫演示數字

private int[] paints=null;

public MergeSortDemonstration(int[] paints){

this.paints= paints;

}

/**

 * 歸併排序

 *

 * start用來記錄在

 * 最開始陣列起始位置

 *

 * @param array

 * @return

 */

public void mergeSort(int[] array,int start){

if(array.length>1){

int len = array.length;

int[] array1 = new int[len/2];

int[] array2 = new int[len-len/2];

System.arraycopy(array,0,array1,0,len/2);

System.arraycopy(array, len/2,array2,0,len-len/2);

//遞迴

mergeSort(array1,start);

mergeSort(array2,start+len/2);

//合併

int index1 = 0;

int index2 = 0;

while(index1<array1.length&&index2<array2.length){

if(array1[index1]<array2[index2]){

array[index1+index2]=array1[index1++];

}

else{

array[index1+index2]=array2[index2++];

}

}

while(index1<array1.length){

array[index1+index2]=array1[index1++];

}

while(index2<array2.length){

array[index1+index2]=array2[index2++];

}

System.arraycopy(array,0,paints,start,array.length);

repaint();

//讓動畫動作變慢

try {

Thread.sleep(800);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

@Override

protected void paintComponent(Graphics g) {

if(getPaints()==null){

return;

}

super.paintComponent(g);

g.setColor(Color.blue);

int width = getWidth();

int height = getHeight();

//畫縱軸

g.drawLine(20,10,20,height-20);

//畫橫軸

g.drawLine(10,height-20,width-20,height-20);

//每個數字多佔寬度

int digitWidth = (width-40)/paints.length;

//獲取最大的數字

int maxNum = 0;

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

if(paints[i]>maxNum){

maxNum=paints[i];

}

}

//根據陣列畫柱狀圖

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

//計算數字位置

int digitX = 20+i*digitWidth+digitWidth/2;

int digitY = height-5;

//畫數字

g.drawString(""+paints[i], digitX, digitY);

//條狀圖高度

int barHeight =(height-30)/maxNum*paints[i];

//畫數字大小對應的條狀圖

g.drawRect(digitX,height-20-barHeight,15,barHeight);

}

}

public int[] getPaints() {

return paints;

}

public void setPaints(int[] paints) {

this.paints = paints;

}

public static void main(String[] args) {

int[] array = {6,3,19,40,45,30,33,35,34,23,18,27,39,14,17,31,36};

MergeSortDemonstration MSD = new MergeSortDemonstration(array);

JFrame JF = new JFrame("歸併排序");

JF.setSize(600,600);

JF.setLocationRelativeTo(null);

JF.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

JF.add(MSD);

JF.setVisible(true);

//排序

MSD.mergeSort(array,0);

}

}

package four.four;

import java.awt.Color;

import java.awt.Graphics;

import javax.swing.JFrame;

import javax.swing.JPanel;

/**

 * 排序演示

 * @author ym

 *

 */

public class QuickSortDemonstration extends JPanel{

/**

 * 序列號

 */

private static final long serialVersionUID = 1L;

public QuickSortDemonstration(int[] array){

this.paints= array;

}

//劃分值下標

private int index=0;

/**

 * 儲存需要畫的陣列

 */

private int[] paints = null;

public int[] getPaints() {

return paints;

}

public void setPaints(int[] paints) {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

this.paints = paints;

repaint();

}

/**

 * 交換兩個元素的順序

 *

 * @param array

 * @param i

 * @param j

 */

public void swap(int[] array,int i,int j,int position){

int temp = array[i];

array[i]=array[j];

array[j]=temp;

//設定劃分元素的下標值

setIndex(position);

//更新待畫陣列

setPaints(array);

}

public int getIndex() {

return index;

}

public void setIndex(int index) {

this.index = index;

}

/**

 * 快速排序

 *

 * @param arr

 * @param i

 * @param j

 */

public void quickSort(int[] array,int i,int j){

if(i<j){

int index = divide(array,i,j);

quickSort(array,i,index-1);

quickSort(array, index+1, j);

}

}

/**

 * 左右掃描分割

 *

 * @param arr

 * @param i

 * @param j

 * @return

 */

public int divide(int[] array,int i,int j){

int index=i;

int patition=array[i];

int low= i+1;

int high=j;

while(low<high){

while(low<high&&array[low]<patition){

low++;

}

while(low<high&&array[high]>patition){

high--;

}

if(low<high){

swap(array,low,high,index);

}

}

while(array[high]>array[index]){

high--;

}

if(high>index){

swap(array,high,index,index);

}

return high;

}

@Override

protected void paintComponent(Graphics g) {

if(getPaints()==null){

return;

}

super.paintComponent(g);

int width = getWidth();

int height = getHeight();

//畫縱軸

g.drawLine(20,10,20,height-20);

//畫橫軸

g.drawLine(10,height-20,width-20,height-20);

//每個數字多佔寬度

int digitWidth = (width-40)/paints.length;

//獲取最大的數字

int maxNum = 0;

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

if(paints[i]>maxNum){

maxNum=paints[i];

}

}

//根據陣列畫柱狀圖

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

//計算數字位置

int digitX = 20+i*digitWidth+digitWidth/2;

int digitY = height-5;

//畫數字

g.drawString(""+paints[i], digitX, digitY);

//條狀圖高度

int barHeight =(height-30)/maxNum*paints[i];

//設定劃分值對應條狀圖的顏色為紅色，其餘為黑色

if(this.index==i){

g.setColor(Color.red);

}

else{

g.setColor(Color.blue);

}

//畫數字大小對應的條狀圖

g.drawRect(digitX,height-20-barHeight,15,barHeight);

}

}

public void print(int[] array){

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

System.out.print(" "+array[i]);

}

System.out.println();

}

public static void main(String[] args) {

int[] array = {6,3,19,40,45,30,33,35,34,23,18,27,39,14,17,31,36};

QuickSortDemonstration SD = new QuickSortDemonstration(array);

JFrame JF = new JFrame("QuickSort");

JF.setSize(600,600);

JF.setLocationRelativeTo(null);

JF.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

JF.add(SD);

JF.setVisible(true);

//排序

SD.quickSort(array, 0, array.length-1);

}

}