Question

昨天我看到了一些关于比较排序算法的精彩视频。我决定写相同的，但刚开始后我发现这种排序可视化非常慢。使用此代码

import javax.swing.*;
import java.awt.*;

class ViewSort extends JFrame implements Runnable{
    private int N = 100;
    private int max = 500;
    private int[] array;
    private Thread th;
    private DrawPanel drawPanel;
    long startTime;
    int iter = 0;

    public ViewSort(){
        init();
    }

    private void init(){
        this.setSize(N*2 + 50, max + 50);
        this.setLayout(new GridLayout(1, 1));
        this.setResizable(false);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setTitle("Stupid Sort Viewer");
        drawPanel = new DrawPanel();
        this.getContentPane().add(drawPanel);
        array = generateArray(N, max);
        th = new Thread(this);
        th.start();
        startTime = System.nanoTime();
    }

    public static int[] generateArray(int N, int max){
        int[] array = new int[N];
        for(int i = 0; i < N; i++){
            array[i] = (int) (Math.random() * max);
        }
        return array;
    }

    @Override
    public void run(){
        for(int i = 0; i < N - 1; i++){
            iter++;
            if(array[i] > array[i + 1]){
               int tmp = array[i];
               array[i] = array[i + 1];
               array[i + 1] = tmp;
               i = 0;
            }
            try{
                th.sleep(1);
            }catch(InterruptedException ie){
                ie.printStackTrace();
            }
            drawPanel.repaint();
        }
        System.out.print((System.nanoTime() - startTime) / 1000 / 1000 / 1000);
        System.out.print(" seconds left on ");
        System.out.print(iter);
        System.out.print(" iterations on sorting an array of ");
        System.out.print(N);
        System.out.print(" integers");
    }

    private void printArray(){
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < N; i++){
            sb.append(array[i]);
            sb.append(" ");
        }
        System.out.println(new String(sb));
    }

    class DrawPanel extends JPanel{            
        public void paintComponent(Graphics g){
            super.paintComponent(g);
            g.setColor(Color.white);
            g.fillRect(0, 0, getWidth(), getHeight());
            g.setColor(Color.black);
            for(int i = 0; i < N; i++){
                g.fillRect(i*2 + 25, getHeight() - array[i], 2, array[i]);
            }
        }
    }

    public static void main(String[] args){
        SwingUtilities.invokeLater(new Runnable(){
            public void run(){
                new ViewSort().setVisible(true);
            }
        });
    }
}

使用该代码我输出像
在116441次迭代上剩余170秒，对100个整数的数组进行排序
附：
我知道排序是最慢的（除了随机排序）但不是这样！

Answer 1

i = Math.max(-1, i - 2);

你有两个问题，都是由上面一行引起的：

1）每当你发现两个号码乱序时，你会回到0并重做比较。但是如果你交换24和25值，你已经知道24之前的值是正确的，所以你只需要返回并比较23和24的值。

2）你将值设置为零，但是for循环将“I”增加1，所以你只能在索引1开始比较，所以第一个值总是乱序（除非它随机发生在最小的值）。

您可以使用以下方法解决这两个问题：

Symbols

注意：

虽然该类可以使用paintChildren（）方法中的绘制代码，但是代码确实应该按照MadProgrammer的建议移动到paintComponent（）方法。自定义绘画应该在paintComponent（）方法中完成。 Swing使用paintChildren（）方法绘制添加到面板的Swing组件。

为什么这种排序可视化很慢？

1 个答案: