可视化冒泡排序代码java

### 回答1：
以下是一个简单的Java程序，用于可视化冒泡排序算法：

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

public class BubbleSortVisualization extends JFrame {
    private JPanel panel;
    private int[] array;

    public BubbleSortVisualization() {
        setTitle("Bubble Sort Visualization");
        setSize(500, 500);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);

        panel = new JPanel();
        add(panel);

        generateRandomArray();
        sortArray();
    }

    private void generateRandomArray() {
        array = new int[50];
        for (int i = 0; i < array.length; i++) {
            array[i] = (int)(Math.random() * 100);
        }
    }

    private void sortArray() {
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j+1]) {
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    drawArray(j, j+1);
                }
            }
        }
    }

    private void drawArray(int index1, int index2) {
        Graphics g = panel.getGraphics();
        g.setColor(Color.WHITE);
        g.fillRect(0, 0, panel.getWidth(), panel.getHeight());
        g.setColor(Color.BLACK);
        int width = panel.getWidth() / array.length;
        int height = panel.getHeight() / 100;
        for (int i = 0; i < array.length; i++) {
            if (i == index1 || i == index2) {
                g.setColor(Color.RED);
            } else {
                g.setColor(Color.BLACK);
            }
            g.fillRect(i * width, panel.getHeight() - array[i] * height, width, array[i] * height);
        }
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        BubbleSortVisualization visualization = new BubbleSortVisualization();
        visualization.setVisible(true);
    }
}

这个程序使用Java Swing库创建一个窗口，并在窗口中绘制一个随机生成的整数数组。然后，它使用经典的冒泡排序算法对数组进行排序，并在每次交换时重新绘制数组。在重新绘制数组时，它会高亮显示正在交换的元素。这个程序只是一个简单的示例，你可以根据自己的需要进行修改和扩展。

### 回答2：
冒泡排序是一种简单但效率较低的排序算法，它不断比较相邻的元素，并依次交换顺序，直到所有元素都按照从小到大（或从大到小）的顺序排列好。下面给出一个可视化冒泡排序的Java代码：

import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;

class BubbleSortPanel extends JPanel implements ActionListener {
    private static final int PANEL_WIDTH = 600;  // 面板宽度
    private static final int PANEL_HEIGHT = 400;  // 面板高度
    private static final int BAR_WIDTH = 20;  // 柱形图宽度
    private static final int BAR_GAP = 5;  // 柱形图间隔
    private static final int DELAY = 100;  // 排序速度

    private int[] arr;  // 待排序数组
    private Timer timer;  // 计时器
    private int currentIdx;  // 当前比较的元素索引

    public BubbleSortPanel() {
        arr = getRandomArray();  // 获取一个随机数组
        timer = new Timer(DELAY, this);  // 创建计时器，并注册监听器
        timer.start();  // 启动计时器
    }

    private int[] getRandomArray() {
        int[] arr = new int[PANEL_WIDTH / (BAR_WIDTH + BAR_GAP)];  // 数组长度根据面板大小计算
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * PANEL_HEIGHT);  // 数组元素为随机高度
        }
        return arr;
    }

    private void bubbleSort() {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(j, j + 1);  // 交换位置
                }
            }
        }
    }

    private void swap(int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        g.setColor(Color.BLACK);

        for (int i = 0; i < arr.length; i++) {
            int x = i * (BAR_WIDTH + BAR_GAP);
            int y = PANEL_HEIGHT - arr[i];

            if (i == currentIdx) {  // 当前比较的元素
                g.setColor(Color.RED);
            } else {
                g.setColor(Color.BLACK);
            }

            g.fillRect(x, y, BAR_WIDTH, arr[i]);
        }
    }

    public void actionPerformed(ActionEvent e) {
        if (currentIdx < arr.length - 1) {
            bubbleSort();  // 调用冒泡排序算法
            currentIdx++;
            repaint();  // 重绘面板
        } else {
            timer.stop();  // 排序完成，停止计时器
        }
    }
}

public class BubbleSortVisualization {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Bubble Sort Visualization");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(BubbleSortPanel.PANEL_WIDTH, BubbleSortPanel.PANEL_HEIGHT);
        frame.setResizable(false);

        BubbleSortPanel panel = new BubbleSortPanel();
        frame.add(panel);
        frame.setVisible(true);
    }
}

这段代码使用Java Swing库创建了一个可视化冒泡排序的面板。在面板中，随机生成一组柱状图用于排序演示。排序过程中，不断交换位置的比较元素会以红色显示，其他元素以黑色显示。通过计时器控制排序速度和重绘面板实现动态效果。运行程序后，将在一个新窗口中看到冒泡排序的可视化过程。

### 回答3：
冒泡排序是一种经典的排序算法，通过不断比较相邻的元素并交换位置来实现排序。这里是用Java编写的冒泡排序代码的可视化实现：

import java.util.Arrays;

public class BubbleSortVisualization {
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        boolean swapped;
        
        for (int i = 0; i < n - 1; i++) {
            swapped = false;
            
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换相邻元素的位置
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    
                    swapped = true;
                }
            }
            
            // 如果在一轮遍历中没有进行任何交换，则表示已经完成排序，可以提前结束循环
            if (!swapped) {
                break;
            }
        }
    }
    
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        System.out.println("原始数组: " + Arrays.toString(arr));
        
        bubbleSort(arr); // 进行冒泡排序
        
        System.out.println("排序后的数组: " + Arrays.toString(arr));
    }
}

这段代码中，我们定义了一个`bubbleSort`函数用于实现冒泡排序。在每一轮遍历中，通过比较相邻元素的大小，并交换位置，将较大的元素逐渐冒泡到数组的末尾。同时，在每轮遍历中，通过标志`swapped`判断是否进行了元素交换，若没有进行交换则表示已经排序完成，可以提前结束排序。最后，通过主函数`main`调用`bubbleSort`函数，输出排序前后的数组。