java插入排序可视化

最新推荐文章于 2024-04-21 08:51:44 发布
最新推荐文章于 2024-04-21 08:51:44 发布
阅读量393 收藏 6
点赞数
分类专栏： java 算法 swing Java学习之路 文章标签： 算法可视化 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CowBoySoBusy/article/details/84494276
版权
java 同时被 3 个专栏收录
48 篇文章 0 订阅
订阅专栏
Java学习之路
48 篇文章 1 订阅
订阅专栏
算法
46 篇文章 1 订阅
订阅专栏

直接上代码和效果图:

AlgoFrame.java

package Test;

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

public class AlgoFrame extends JFrame{

    private int canvasWidth;
    private int canvasHeight;

    public AlgoFrame(String title, int canvasWidth, int canvasHeight){

        super(title);

        this.canvasWidth = canvasWidth;
        this.canvasHeight = canvasHeight;

        AlgoCanvas canvas = new AlgoCanvas();
        setContentPane(canvas);
        pack();

        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setResizable(false);

        setVisible(true);
    }

    public AlgoFrame(String title){

        this(title, 1024, 768);
    }

    public int getCanvasWidth(){return canvasWidth;}
    public int getCanvasHeight(){return canvasHeight;}

    // data
    private InsertionSortData data;
    public void render(InsertionSortData data){
        this.data = data;
        repaint();
    }

    private class AlgoCanvas extends JPanel{

        public AlgoCanvas(){
            // 双缓存
            super(true);
        }

        @Override
        public void paintComponent(Graphics g) {
            super.paintComponent(g);

            Graphics2D g2d = (Graphics2D)g;

            // 抗锯齿
            RenderingHints hints = new RenderingHints(
                    RenderingHints.KEY_ANTIALIASING,
                    RenderingHints.VALUE_ANTIALIAS_ON);
            hints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
            g2d.addRenderingHints(hints);

            // 具体绘制
            int w = canvasWidth/data.N();
            //AlgoVisHelper.setColor(g2d, AlgoVisHelper.Grey);
            for(int i = 0 ; i < data.N() ; i ++ ) {
                if (i < data.orderedIndex)
                    AlgoVisHelper.setColor(g2d, AlgoVisHelper.Red);
                else
                    AlgoVisHelper.setColor(g2d, AlgoVisHelper.Grey);

                if( i == data.currentIndex )
                    AlgoVisHelper.setColor(g2d, AlgoVisHelper.LightBlue);
                AlgoVisHelper.fillRectangle(g2d, i * w, canvasHeight - data.get(i), w - 1, data.get(i));
            }
        }

        @Override
        public Dimension getPreferredSize(){
            return new Dimension(canvasWidth, canvasHeight);
        }
    }
}

AlgoVisHelper.java

package Test;

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

import java.lang.InterruptedException;

public class AlgoVisHelper {

    private AlgoVisHelper(){}

    public static final Color Red = new Color(0xF44336);
    public static final Color Pink = new Color(0xE91E63);
    public static final Color Purple = new Color(0x9C27B0);
    public static final Color DeepPurple = new Color(0x673AB7);
    public static final Color Indigo = new Color(0x3F51B5);
    public static final Color Blue = new Color(0x2196F3);
    public static final Color LightBlue = new Color(0x03A9F4);
    public static final Color Cyan = new Color(0x00BCD4);
    public static final Color Teal = new Color(0x009688);
    public static final Color Green = new Color(0x4CAF50);
    public static final Color LightGreen = new Color(0x8BC34A);
    public static final Color Lime = new Color(0xCDDC39);
    public static final Color Yellow = new Color(0xFFEB3B);
    public static final Color Amber = new Color(0xFFC107);
    public static final Color Orange = new Color(0xFF9800);
    public static final Color DeepOrange = new Color(0xFF5722);
    public static final Color Brown = new Color(0x795548);
    public static final Color Grey = new Color(0x9E9E9E);
    public static final Color BlueGrey = new Color(0x607D8B);
    public static final Color Black = new Color(0x000000);
    public static final Color White = new Color(0xFFFFFF);

    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);
    }

    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);
    }

    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);
    }

    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);
    }

    public static void setColor(Graphics2D g, Color color){
        g.setColor(color);
    }

    public static void setStrokeWidth(Graphics2D g, int w){
        int strokeWidth = w;
        g.setStroke(new BasicStroke(strokeWidth, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
    }

    public static void pause(int t) {
        try {
            Thread.sleep(t);
        }
        catch (InterruptedException e) {
            System.out.println("Error sleeping");
        }
    }

    public static void putImage(Graphics2D g, int x, int y, String imageURL){

        ImageIcon icon = new ImageIcon(imageURL);
        Image image = icon.getImage();

        g.drawImage(image, x, y, null);
    }

    public static void drawText(Graphics2D g, String text, int centerx, int centery){

        if(text == null)
            throw new IllegalArgumentException("Text is null in drawText function!");

        FontMetrics metrics = g.getFontMetrics();
        int w = metrics.stringWidth(text);
        int h = metrics.getDescent();
        g.drawString(text, centerx - w/2, centery + h);
    }
}

AlgoVisualizer.java

package Test;

import java.awt.*;

public class AlgoVisualizer {

    private static int DELAY = 10;

    private InsertionSortData data;
    private AlgoFrame frame;

    public AlgoVisualizer(int sceneWidth, int sceneHeight, int N){

        // 初始化数据
        data = new InsertionSortData(N, sceneHeight);

        // 初始化视图
        EventQueue.invokeLater(() -> {
            frame = new AlgoFrame("Insertion Sort Visualization", sceneWidth, sceneHeight);

            new Thread(() -> {
                run();
            }).start();
        });
    }

    public void run(){

        setData(0, -1);

        for( int i = 0 ; i < data.N() ; i ++ ){

            setData(i, i);
            for(int j = i ; j > 0 && data.get(j) < data.get(j-1) ; j --){
                data.swap(j,j-1);
                setData(i+1, j-1);
            }
        }
        setData(data.N(), -1);

    }

    private void setData(int orderedIndex, int currentIndex){
        data.orderedIndex = orderedIndex;
        data.currentIndex = currentIndex;

        frame.render(data);
        AlgoVisHelper.pause(DELAY);
    }

    public static void main(String[] args) {

        int sceneWidth = 800;
        int sceneHeight = 800;
        int N = 100;

        AlgoVisualizer vis = new AlgoVisualizer(sceneWidth, sceneHeight, N);
    }
}

InsertionSortData.java

package Test;

public class InsertionSortData {

    private int[] numbers;
    public int orderedIndex = -1;   // [0...orderedIndex) 是有序的
    public int currentIndex = -1;

    public InsertionSortData(int N, int randomBound){

        numbers = new int[N];

        for( int i = 0 ; i < N ; i ++)
            numbers[i] = (int)(Math.random()*randomBound) + 1;
    }

    public int N(){
        return numbers.length;
    }

    public int get(int index){
        if( index < 0 || index >= numbers.length)
            throw new IllegalArgumentException("Invalid index to access Sort Data.");

        return numbers[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;
    }
}

在这里插入图片描述

在这里插入图片描述
众所周知,当这一组需要排序的数近乎有序时,插入排序算法的时间复杂度为O(N).
下面研究一下需要排序的数近乎有序时候的情况:
AlgoVisualizer.java

package Test;

import java.awt.*;

public class AlgoVisualizer {

    private static int DELAY = 10;

    private InsertionSortData data;
    private AlgoFrame frame;

    public AlgoVisualizer(int sceneWidth, int sceneHeight, int N, InsertionSortData.Type dataType){

        // 初始化数据
        data = new InsertionSortData(N, sceneHeight, dataType);

        // 初始化视图
        EventQueue.invokeLater(() -> {
            frame = new AlgoFrame("Insertion Sort Visualization", sceneWidth, sceneHeight);

            new Thread(() -> {
                run();
            }).start();
        });
    }

    public AlgoVisualizer(int sceneWidth, int sceneHeight, int N){
        this(sceneWidth, sceneHeight, N, InsertionSortData.Type.Default);
    }

    public void run(){

        setData(0, -1);

        for( int i = 0 ; i < data.N() ; i ++ ){

            setData(i, i);
            for(int j = i ; j > 0 && data.get(j) < data.get(j-1) ; j --){
                data.swap(j,j-1);
                setData(i+1, j-1);
            }
        }
        this.setData(data.N(), -1);

    }

    private void setData(int orderedIndex, int currentIndex){
        data.orderedIndex = orderedIndex;
        data.currentIndex = currentIndex;

        frame.render(data);
        AlgoVisHelper.pause(DELAY);
    }

    public static void main(String[] args) {

        int sceneWidth = 800;
        int sceneHeight = 800;
        int N = 100;

        AlgoVisualizer vis = new AlgoVisualizer(sceneWidth, sceneHeight, N, InsertionSortData.Type.NearlyOrdered);
    }
}

InsertionSortData.java

package Test;

import java.util.Arrays;


public class InsertionSortData {

    public enum Type{
        Default,
        NearlyOrdered
    }

    private int[] numbers;
    public int orderedIndex;           // [0...orderedIndex) 是有序的
    public int currentIndex;

    public InsertionSortData(int N, int randomBound, Type dataType){

        numbers = new int[N];

        for( int i = 0 ; i < N ; i ++)
            numbers[i] = (int)(Math.random()*randomBound) + 1;

        if(dataType == Type.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);
            }
        }
    }

    public InsertionSortData(int N, int randomBound){
        this(N, randomBound, Type.Default);
    }

    public int N(){
        return numbers.length;
    }

    public int get(int index){
        if( index < 0 || index >= numbers.length)
            throw new IllegalArgumentException("Invalid index to access Sort Data.");

        return numbers[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;
    }
}

在这里插入图片描述
这个时候会发现程序运行速度明显比第一次要快很多.

29DCH
关注
专栏目录
JAVA可视化排序
01-10
本篇文章将深入探讨如何在Java中实现动态排序可视化。 首先，我们要了解排序算法。常见的排序算法有冒泡排序、选择排序、插入排序、快速排序、归并排序等。这些算法在处理数据时各有优劣，例如冒泡排序简单但效率较...
【UML】顺序图
橙子的博客
11-08 1655
时序图是可视化地展示对象与对象之间的联系的图，与其他的图相比，它跟侧重于表现为了完成一个用例，对象之间是怎么协同工作的。顺序图是UML两种交互图之一（另一种是协作图）
UML建模图文详解教程06——顺序图
谷哥的小弟
11-23 5939
顺序图(sequence diagram，也被称为为序列图或时序图)是按时间顺序显示对象交互的图。具体来说，它显示了参与交互的对象和所交换信息的先后顺序，用来表示用例中的行为并将这些行为建模成信息交换。顺序图主要包括四个元素：对象(object)、生命线(lifeline)、激活(activation)和消息(message)。在 UML中，顺序图将交互关系表示为一张二维图。其中纵向代表时间维度时间向下延伸，按时间依次列出各个对象所发出和接收的消息。横向代表对象的维度，排列着参与交互的各个独立的对象。
算法可视化？用动画的方式讲解插入排序
linwu的博客
07-04 281
插入排序适用于小规模数据的排序。在数据量较小的情况下，插入排序具有较高的效率。特别是对几乎有序的数据进行排序时，插入排序的性能优于其他排序算法。在标准库中的排序算法（如STL的sort函数和JavaScript的Array.prototype.sort方法）中，插入排序通常被用作快速排序的辅助算法，用于排序小规模的子数组。
十大基本排序算法的简易可视化
weixin_63025701的博客
08-22 1321
本文利用Microsoft Visual Studio的C语言编写平台及其自带的输出窗口尝试制作了十种基本排序算法的简单可视化。最终的输出都是文字、数字与符号，笔者已经尽力调整其位置以让结果尽可能清楚。本来是自己在学习排序算法的时候希望可以看到输入的数据在计算机内部被操作的过程，这样方便理解，同时又想用尽可能简单（懒）的方式实现，所以做了这些尝试。相比于网上的动画式可视化工具，本方法在视觉效果上略逊一筹。
插入排序的可视化实现（Python）
最新发布
计算机视觉之光
04-21 236
【代码】插入排序的可视化实现（Python）
java排序可视化页面
12-08
Java排序可视化页面是一种用于教学和理解排序算法的强大工具。它通过图形化的方式展示了排序过程，使得用户能够直观地看到冒泡排序、选择排序和插入排序这三种基础排序算法的工作原理。接下来，我们将深入探讨这些...
InsertionSort:可视化插入排序算法
05-22
在提供的`InsertionSort-master`压缩包中，可能包含了一个Java项目，该项目可能用于演示插入排序和快速排序的可视化效果，或者提供了这两种排序算法的Java实现代码。通过阅读和理解这些代码，我们可以更好地学习和...
可视化排序算法
02-15
在Java中实现可视化排序，可以帮助开发者更好地学习和调试排序算法，尤其是在教学和研究场景下，这种可视化工具非常有帮助。在这个项目中，我们将深入探讨如何使用Java来实现各种常见的可视化排序算法。 首先，我们...
java 排序算法可视化
08-14
用java做的一个小的排序算法演示程序，用线程控制访问，共7个算法，包括冒泡，选择，希尔，插入，归并，堆，快排。。
算法可视化系列——排序算法——插入排序
04-19
NULL 博文链接：https://wojiaolongyinong.iteye.com/blog/1867026
可视化插入排序算法
多米学算法的博客
06-03 518
前言 概念介绍 取出数组中无序部分的第一个元素，从后向前检查数组有序部分元素，将其插入到一个适当位置，使数组有序部分依然有序。当无序部分最后一个元素放入合适位置时，该数组排序完毕。 原理讲解 以41 34 19 17 2这个序列为例说明选择排序的实现原理 未开始遍历时，此时效果如下图 第一次遍历时，我们取出第一个元素41，并假定该元素已经有序。此时有序部分元素为41，无序部分元素为34 19 17 2。效果如下图 第二次遍历时，我们取出无序部分第一个元素34，检查有序部.
JS中可视化插入排序
CedricD的博客
05-20 250
插入排序 插入排序的原理如下。第一个元素默认是已排序元素，取出下一个元素和当前元素比较，如果当前元素大就交换位置。那么此时第一个元素就是当前的最小数，所以下次取出操作从第三个元素开始，向前对比，重复之前的操作。 以下是实现该算法的代码 var arr = [8,3,54,7,12,9,6]; for(var i=1;i<arr.length;i++){ var temp = arr[i]; for(var j = i;j>0;j--){ if(arr[j]&gt
java在图片上面写文字质量很差以及文字周边模糊问题解决
zhong_jianyu的专栏
01-17 2417
java在图片上面写文字质量很差以及文字周边模糊问题解决
Java 快速排序算法可视化
moonlightpeng的博客
08-22 354
java
java jai指南,使用Java JAI缩放图像
weixin_42165583的博客
02-13 416
I have to scale an image with Java JAI. At the time now, I use the following code:private static RenderedOp scale(RenderedOp image, float scale) {ParameterBlock scaleParams = new ParameterBlock();scal...
算法基础1——插入排序
fogsail的博客
04-21 362
一、插入排序 在许多经典的书籍中，插入排序的算法涉及到两张牌：1、递归牌；2、当前牌。 具体的可视化的步骤如下图：
可视化排序实践之插入排序
u010633678的专栏
05-08 296
本博文的程序实现对插入排序的可视化。具体的页面布局和之前的文章“可视化排序实践之冒泡排序”一致 （界面很简单就包括两个部分：界面左侧是可视化排序部分，右侧是冒泡排序的代码）， 可视化排序实践之冒泡排序的博文请参考： [url]http://mouselearnjava.iteye.com/blog/1860956[/url] 可视化排序实践之选择排序的博文请参考： [url]http://m...
Java GUI实现的8种排序算法可视化
以上这些算法都是算法学习者必须掌握的基础知识，而通过Java GUI的可视化展示，可以更加直观地理解每种排序算法的执行过程和特点。对于初学者来说，通过实践可视化项目能够加深对理论知识的理解，并为解决实际问题...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值