如何制作QuickSort图形？

Question

My current code does "QuickSorting" fine however, it displays sorted on the second print of screen. I want to have a better visualization of what's happening when i invoke "QuickSort", so as to have it sorted in around 5 prints of screen. My code is underneath.

1

public class Frame1 extends javax.swing.JFrame {

  public Presentation() {
    initComponents();    
  }

  MyArrayClass myArrayObject = new MyArrayClass(25);

  public void BeginTimer() {
    class RemindTask extends TimerTask {                                  
      @Override            
        public void run() {                                
          paintAndSort();                
        }
    }  
    new Timer().scheduleAtFixedRate(new RemindTask(), 2000, 2000);
  }

  public void paintAndSort() {        
    int size = Integer.parseInt(txtSizeOfArray.getText());
    Graphics g = this.getGraphics();
    g.clearRect(15, 200, 270, 200);
    g.drawRect(15, 200, 270, 200);
    g.setColor(Color.DARK_GRAY);
    int x = 15;

    for (int i = 0; i < size; i++) {
       int value = myArrayObject.MyArray[i];
       g.fillRect(x, 300 - value, 9, value);
       x += 10;
    }        
    sortIt();            
  }

  Public void sortIt() {
     int size = Integer.parseInt(txtSizeOfArray.getText());
     myArrayObject.quickSort(0, size - 1);
  }
} 

2

public class MyArrayClass {

int myArray[];
int arraySize;    
int result;

  public MyArrayClass(int size) {
    arraySize = size;
    myArray = new int[arraySize];
  }

  public void numberGenerator() {        
     for (int i = 0; i < arraySize; i++) {
       myArray[i] = (int) (Math.random() * 99) + 1;            
     }
  }  

  public void quickSort(int left, int right) {
     if (right - left <= 0) {
       return;
     }  else {
       int pivot = myArray[right];            
       partitioning(left, right, pivot);
       int pivotValue = result;
       quickSort(left, pivotValue - 1);
       quickSort(pivotValue + 1, right);
     }
  }

  public void partitioning(int left, int right, int pivot) {
    int leftP = left - 1;
    int rightP = right;
      while (true) {
         while (leftP < right && myArray[++leftP] < pivot) {                
         }
         while (rightP > 0 && myArray[--rightP] > pivot) {                
         }
         if (rightP <= leftP) {
           swapValues(leftP, right);
           result = leftP;
           break;
         } else {
           swapValues(leftP, rightP);
           break;
         }
      }  
  }  

  private void swapValues(int leftP, int rightP) {
    int aux = myArray[leftP];
    myArray[leftP] = myArray[rightP];
    myArray[rightP] = aux;
  }
}

Answer 1

There are some issues with the code. In general:

NEVER call getGraphics on a Component !

Apart from that, some minor things (don't extend JFrame, create the GUI on the EDT, and the naming conventions mentioned in the comments).

The current structure of the code does not make it really easy to connect it to a GUI component. You should clearly think about how this connection should be established, and at which points in time you want the component to be updated.

This example shows how this could basically be done. It is not a very nice and generic structure, but I did not want to completely re-write your MyArrayClass or generate a huge infrastructure of interfaces, timers, listeners etc. around it. It only shows a very simple and very pragmatic approach.

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

public class GraphicalQuickSort
{
    public static void main(String[] args) 
    {
        SwingUtilities.invokeLater(new Runnable()
        {
            @Override
            public void run()
            {
                createAndShowGUI();
            }
        });
    }

    private static void createAndShowGUI()
    {
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().setLayout(new BorderLayout());

        final MyArrayClass myArrayClass = new MyArrayClass(25);
        myArrayClass.NumberGenerator();
        GraphicalQuickSortPanel panel = 
            new GraphicalQuickSortPanel(myArrayClass);
        myArrayClass.graphicalQuickSortPanel = panel;

        JButton sortButton = new JButton("Sort");
        sortButton.addActionListener(new ActionListener()
        {
            @Override
            public void actionPerformed(ActionEvent e)
            {
                performSorting(myArrayClass);
            }
        });
        f.getContentPane().add(sortButton, BorderLayout.NORTH);

        f.getContentPane().add(panel, BorderLayout.CENTER);
        f.setSize(400,400);
        f.setLocationRelativeTo(null);
        f.setVisible(true);
    }

    private static void performSorting(final MyArrayClass myArrayClass)
    {
        Thread thread = new Thread(new Runnable()
        {
            @Override
            public void run()
            {
                myArrayClass.QuickSort(0, myArrayClass.ArraySize-1);
                System.out.println("Done");
            }
        });
        thread.start();
    }
}

class GraphicalQuickSortPanel extends JPanel 
{
    private final MyArrayClass myArrayClass;

    public GraphicalQuickSortPanel(MyArrayClass myArrayClass) 
    {
          this.myArrayClass = myArrayClass;
    }

    @Override
    protected void paintComponent(Graphics g)
    {
        super.paintComponent(g);
        g.setColor(Color.BLACK);
        int size = myArrayClass.ArraySize;
        int barWidth = getWidth() / size; 

        for (int i = 0; i < size; i++) 
        {
            int value = myArrayClass.MyArray[i];
            int x = i * barWidth;
            int y = getHeight()-value;
            g.fillRect(x+1, y, barWidth-2, value);
        }        
    }
}


class MyArrayClass {

    int MyArray[];
    int ArraySize;    
    int res;

    // This should NOT be a direct reference, but
    // a generic listener instead!
    GraphicalQuickSortPanel graphicalQuickSortPanel;
    long delayAfterSwapMS = 500;

    public MyArrayClass(int size) {
        ArraySize = size;
        MyArray = new int[ArraySize];
    }

    public void NumberGenerator() {        
        for (int i = 0; i < ArraySize; i++) {
            MyArray[i] = (int) (Math.random() * 99) + 1;            
        }
    }  

    public void QuickSort(int Left, int Right) {
        if (Right - Left <= 0) {
            return;
        }  else {
            int Pivot = MyArray[Right];            
            Partitioning(Left, Right, Pivot);
            int PivotValue = res;
            QuickSort(Left, PivotValue - 1);
            QuickSort(PivotValue + 1, Right);
        }
    }

    public void Partitioning(int Left, int Right, int Pivot) {
        int LeftP = Left - 1;
        int RightP = Right;
        while (true) {
            while (LeftP < Right && MyArray[++LeftP] < Pivot) {                
            }
            while (RightP > 0 && MyArray[--RightP] > Pivot) {                
            }
            if (RightP <= LeftP) {
                SwapValues(LeftP, Right);
                res = LeftP;
                break;
            } else {
                SwapValues(LeftP, RightP);
                break;
            }
        }  
    }  

    private void SwapValues(int LeftP, int RightP) {
        int aux = MyArray[LeftP];
        MyArray[LeftP] = MyArray[RightP];
        MyArray[RightP] = aux;

        // This should be solved differently
        try
        {
            Thread.sleep(delayAfterSwapMS);
        }
        catch (InterruptedException e)
        {
            Thread.currentThread().interrupt();
        }
        graphicalQuickSortPanel.repaint();
    }
}