Chapter 04 section 11 codes updated.

Author: liuyubobobo

04-Sort-Visualization/11-Heap-Sort-Visualization/src/AlgoFrame.java

@@ -1,16 +1,10 @@
-import java.awt.Graphics2D;
-import java.awt.Graphics;
-import java.awt.Dimension;
-import java.awt.Color;
-import java.awt.RenderingHints;
-
+import java.awt.*;
 import javax.swing.*;
 
 public class AlgoFrame extends JFrame{
 
     private int canvasWidth;
     private int canvasHeight;
-    private JPanel canvas;
 
     public AlgoFrame(String title, int canvasWidth, int canvasHeight){
 
@@ -38,8 +32,8 @@ public AlgoFrame(String title){
     public int getCanvasHeight(){return canvasHeight;}
 
     // data
-    HeapSortData data;
-    public void setData(HeapSortData data){
+    private HeapSortData data;
+    public void render(HeapSortData data){
         this.data = data;
         repaint();
     }
@@ -66,7 +60,6 @@ public void paintComponent(Graphics g) {
 
             // 具体绘制
             int w = canvasWidth/data.N();
-            //AlgoVisHelper.setColor(g2d, AlgoVisHelper.Grey);
             for(int i = 0 ; i < data.N() ; i ++ ) {
                 if ( i >= data.heapIndex)
                     AlgoVisHelper.setColor(g2d, AlgoVisHelper.Red);

04-Sort-Visualization/11-Heap-Sort-Visualization/src/AlgoVisHelper.java

@@ -4,7 +4,6 @@
 import java.awt.geom.Rectangle2D;
 import java.lang.InterruptedException;
 
-
 public class AlgoVisHelper {
 
     private AlgoVisHelper(){}
@@ -31,36 +30,35 @@ private AlgoVisHelper(){}
     public static final Color Black = new Color(0x000000);
     public static final Color White = new Color(0xFFFFFF);
 
-
-    static public void strokeCircle(Graphics2D g, int x, int y, int r){
+    public static void strokeCircle(Graphics2D g, int x, int y, int r){
 
         Ellipse2D circle = new Ellipse2D.Double(x-r, y-r, 2*r, 2*r);
         g.draw(circle);
     }
 
-    static public void fillCircle(Graphics2D g, int x, int y, int r){
+    public static void fillCircle(Graphics2D g, int x, int y, int r){
 
         Ellipse2D circle = new Ellipse2D.Double(x-r, y-r, 2*r, 2*r);
         g.fill(circle);
     }
 
-    static public void strokeRectangle(Graphics2D g, int x, int y, int w, int h){
+    public static void strokeRectangle(Graphics2D g, int x, int y, int w, int h){
 
         Rectangle2D rectangle = new Rectangle2D.Double(x, y, w, h);
         g.draw(rectangle);
     }
 
-    static public void fillRectangle(Graphics2D g, int x, int y, int w, int h){
+    public static void fillRectangle(Graphics2D g, int x, int y, int w, int h){
 
         Rectangle2D rectangle = new Rectangle2D.Double(x, y, w, h);
         g.fill(rectangle);
     }
 
-    static public void setColor(Graphics2D g, Color color){
+    public static void setColor(Graphics2D g, Color color){
         g.setColor(color);
     }
 
-    static public void setStrokeWidth(Graphics2D g, int w){
+    public static void setStrokeWidth(Graphics2D g, int w){
         int strokeWidth = w;
         g.setStroke(new BasicStroke(strokeWidth, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
     }

04-Sort-Visualization/11-Heap-Sort-Visualization/src/AlgoVisualizer.java

@@ -1,44 +1,43 @@
 import java.awt.*;
-import java.util.Random;
-import java.util.Arrays;
+
 
 public class AlgoVisualizer {
 
-    private static int DELAY = 40;
+    private static int DELAY = 20;
 
     private HeapSortData data;
     private AlgoFrame frame;
 
-    public AlgoVisualizer(AlgoFrame frame, HeapSortData data){
+    public AlgoVisualizer(int sceneWidth, int sceneHeight, int N){
+
+        // 初始化数据
+        data = new HeapSortData(N, sceneHeight);
 
-        this.frame = frame;
-        this.data = data;
+        // 初始化视图
+        EventQueue.invokeLater(() -> {
+            frame = new AlgoFrame("Heap Sort Visualization", sceneWidth, sceneHeight);
 
-        this.setData(data.N());
+            new Thread(() -> {
+                run();
+            }).start();
+        });
     }
 
     public void run(){
 
-        heapSort();
+        setData(data.N());
 
-        this.setData(0);
-        AlgoVisHelper.pause(DELAY);
-    }
-
-    private void heapSort(){
-
-        for( int i = (data.N()-1-1)/2 ; i >= 0 ; i -- )
+        for( int i = (data.N()-1-1)/2 ; i >= 0 ; i -- ){
             shiftDown(data.N(), i);
+        }
 
         for( int i = data.N()-1; i > 0 ; i-- ){
             data.swap(0, i);
             shiftDown(i, 0);
             setData(i);
-            AlgoVisHelper.pause(DELAY);
         }
 
         setData(0);
-        AlgoVisHelper.pause(DELAY);
     }
 
     private void shiftDown(int n, int k){
@@ -52,36 +51,26 @@ private void shiftDown(int n, int k){
                 break;
 
             data.swap(k, j);
-            setData(-1);
-            AlgoVisHelper.pause(DELAY);
+            setData(data.heapIndex);
+
             k = j;
         }
     }
 
     private void setData(int heapIndex){
-        if(heapIndex != -1)
-            data.heapIndex = heapIndex;
-        frame.setData(data);
+
+        data.heapIndex = heapIndex;
+
+        frame.render(data);
+        AlgoVisHelper.pause(DELAY);
     }
 
     public static void main(String[] args) {
 
         int sceneWidth = 800;
         int sceneHeight = 800;
+        int N = 100;
 
-        EventQueue.invokeLater(() -> {
-            AlgoFrame frame = new AlgoFrame("Heap Sort Visualization", sceneWidth,sceneHeight);
-
-            int N = 200;
-            // int N = 100;
-
-            HeapSortData data = new HeapSortData(N, sceneHeight, false);
-            // HeapSortData data = new HeapSortData(N, sceneHeight, true);
-            // HeapSortData data = new HeapSortData(N, sceneHeight/2 - 5, sceneHeight/2 + 5);
-            AlgoVisualizer vis = new AlgoVisualizer(frame, data);
-            new Thread(() -> {
-                vis.run();
-            }).start();
-        });
+        AlgoVisualizer vis = new AlgoVisualizer(sceneWidth, sceneHeight, N);
     }
 }

04-Sort-Visualization/11-Heap-Sort-Visualization/src/HeapSortData.java

@@ -1,48 +1,21 @@
 import java.util.Arrays;
-import java.util.Random;
-
 
 public class HeapSortData {
 
-    private int N;
-
     public int[] numbers;
-    public int heapIndex;
+    public int heapIndex;   // numbers[heapIndex...N) 已经排好序
 
-    // 生成N个[0,randomBound)之间的随机数；nearlyOrdered控制随机数是否近乎有序
-    public HeapSortData(int N, int randomBound, boolean nearlyOrdered){
-        this.N = N;
+    public HeapSortData(int N, int randomBound){
 
         numbers = new int[N];
         heapIndex = N;
 
         for( int i = 0 ; i < N ; i ++)
             numbers[i] = (int)(Math.random()*randomBound) + 1;
-
-        if(nearlyOrdered){
-            Arrays.sort(numbers);
-            int swapTime = (int)(0.02*N);
-            for(int i = 0 ; i < swapTime; i ++){
-                int a = (int)(Math.random()*N);
-                int b = (int)(Math.random()*N);
-                swap(a, b);
-            }
-        }
-    }
-
-    // 生成N个[lBound,rBound]之间的随机数
-    public HeapSortData(int N, int lBound, int rBound){
-        this.N = N;
-
-        numbers = new int[N];
-        heapIndex = N;
-
-        for( int i = 0 ; i < N ; i ++)
-            numbers[i] = (int)(Math.random()*(rBound-lBound+1)) + lBound;
     }
 
     public int N(){
-        return N;
+        return numbers.length;
     }
 
     public int get(int index){
@@ -53,6 +26,10 @@ public int get(int index){
     }
 
     public void swap(int i, int j) {
+
+        if( i < 0 || i >= numbers.length || j < 0 || j >= numbers.length)
+            throw new IllegalArgumentException("Invalid index to access Sort Data.");
+
         int t = numbers[i];
         numbers[i] = numbers[j];
         numbers[j] = t;