Java实现排序的可视化
java实现排序算法的可视化
- 内部排序
- 先看以下运行效果
- 一、 类图
- 二、类列表
- 三、源代码
- Sort接口
- Visual 抽象类
- VisibleSort
- MainTest类
- ArrayNeedToSort
- InsertSort类（直接插入排序）
- BubbleSort类（冒泡排序）
- ShellSort类（希尔排序）
- QuickSort类（快速排序）
- BinarySort类（折半插入排序）
- SelectSort（简单选择排序）
内部排序
- ->插入类排序
- –>直接插入排序(insert sort)
- –>折半插入排序(binary sort)
- –>希尔排序(shell sort)
- ->交换类排序
- –>冒泡排序(bubble sort)
- –>快速排序(quick sort)
- ->选择类排序
- –>简单选择排序（select sort）
- –>树形选择排序
- –>堆排序
- ->归并排序
- ->分配类排序
- –>多关键字排序
- –>链式基数排序
先看以下运行效果
github源码: github源码
运行视频：运行效果视频.
一、 类图
二、类列表
三、源代码
Sort接口
为各个排序方法类提供一个共同的方法
/**
* 排序算法的接口
* a interface of sorting
* */
public interface Sort {
//进行排序(sorting)
abstract void startSort();
}
Visual 抽象类
public abstract class Visual extends JPanel implements Sort,Runnable{
//窗口
public abstract void windowFrom();
}
VisibleSort
/**
* 界面和数组的可视化
* to make sort visually
* */
public class VisibleSort extends Visual{
JFrame jFrame;
ArrayNeedToSort array;
VisibleSort() {
array = new ArrayNeedToSort();
array.initalArray();
array.messArray();
windowFrom();
}
//排序可视化
public void paint(Graphics g) {
//每次画之前都要先清空画板
g.clearRect(0, 0, 1500,800);
for (int i = 0; i < 100; i++) {
g.setColor(Color.BLACK);
g.fillRect(i*10+100,(500-(array.get(i)*4)),10, array.get(i)*4);
}
}
//窗口设置
public void windowFrom() {
jFrame = new JFrame();
jFrame.setSize(1200,580);
jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jFrame.setLocationRelativeTo(null);
jFrame.add(this);
jFrame.setVisible(true);
}
@Override
public void startSort() {
// TODO Auto-generated method stub
}
@Override
public void run() {
// TODO Auto-generated method stub
}
}
MainTest类
/**
* 主函数
* the entrance of this program
* /
public class MainTest {
public static void main(String[] args) {
//直接插入排序(insert sort)
InsertSort insertSort = new InsertSort();
insertSort.startSort();
//冒泡排序(bubble sort)
BubbleSort bubbleSort = new BubbleSort();
bubbleSort.startSort();
//希尔排序(shell sort)
ShellSort shellSort = new ShellSort();
shellSort.startSort();
//快速排序(quick sort)
QuickSort quickSort = new QuickSort();
quickSort.startSort();
//折半插入排序(binary sort)
BinarySort binarySort = new BinarySort();
binarySort.startSort();
}
}
ArrayNeedToSort
/**
* 用来排序的数组
* the arrary ready to sort
* */
public class ArrayNeedToSort {
int[] array;
ArrayNeedToSort() {
array = new int[100];
}
//初始化数组
public void initalArray() {
for (int i = 0; i < 100; i++) {
array[i] = i + 1;
}
}
//伪随机打乱数组
public void messArray() {
for (int i = 0; i < 100; i++) {
int temp = array[i];
int j = (int)(Math.random()*100);
if (i != j) {
array[i] = array[j];
array[j] = temp;
}
}
}
//获得指定下标的数组元素
public int get(int i) {
if (i > 100 || i < 0) {
System.err.println("下标错误！");
}else {
return array[i];
}
return 0;
}
//设置指定下标的数组元素
//即：temp替换 array[i]的值
public void set(int temp,int i) {
if (i > 100 || i < 0) {
System.err.println("下标错误！");
}else {
array[i] = temp; //修改下标为i的数组的值
}
}
}
InsertSort类（直接插入排序）
/**
* 插入排序----直接插入排序(insert sort---InsertSort)
* */
public class InsertSort extends VisibleSort{
Thread thread ;
InsertSort(){
thread = new Thread(this);
thread.start();
}
@Override
public void run() {
while (true) {
try {
startSort();
} catch (Exception e) {
System.err.println("错误！");
}
}
}
//直接插入排序可视化
@Override
public void startSort() {
for (int i = 1; i < 100; i++) {
int temp = super.array.get(i); //把要插入排序的数先暂存到临时变量中
int j = i - 1; //用于标记插入位置
while(temp < array.get(j)) {//寻找插入位置
array.set(array.get(j), j+1);
j -= 1;
try {
Thread.sleep(10); //每次重画都要有一定的延迟，为了看清！
} catch (Exception e) {}
super.repaint();
}
array.set(temp, j+1);
}
//排序完成停2s退出
try {
Thread.sleep(2000);
} catch (Exception e) {}
super.jFrame.setVisible(false);
}
}
BubbleSort类（冒泡排序）
/**
* 交换类排序---冒泡排序(exchange sort---BubbleSort)
* */
public class BubbleSort extends VisibleSort{
Thread thread;
BubbleSort(){
thread = new Thread(this);
thread.start();
}
@Override
public void run() {
while(true) {
try {
startSort();
} catch (Exception e) {}
}
}
@Override
public void startSort() {
try {
Thread.sleep(500);
} catch (Exception e) {}
for (int i = 0; i <= 98; i++) {
for (int j = 0; j <= 98-i; j++) {
if (array.get(j) > array.get(j+1)) {
//调换位置(change location)
int temp = array.get(j);
array.set(array.get(j+1), j);
array.set(temp, j+1);
//重画--redraw
try {
Thread.sleep(10);
} catch (Exception e) {}
repaint();
}
}
}
//悬停2s后隐藏 hide this frame after 2s
try {
Thread.sleep(2000);
} catch (Exception e) {}
super.jFrame.setVisible(false);
}
}
ShellSort类（希尔排序）
/**
* 插入排序---希尔排序(insert sort---shell sort)
* */
public class ShellSort extends VisibleSort {
Thread thread;
int[] delta = {4,2,1}; //增量
ShellSort(){
thread = new Thread(this);
thread.start();
}
@Override
public void run() {
while(true) {
try {
startSort();
} catch (Exception e) {}
}
}
@Override
public void startSort() {
try {
Thread.sleep(500);
} catch (Exception e) {}
for (int i = 0; i < 3; i++) {
shellSort(delta[i]);
}
try {
Thread.sleep(2000);
} catch (Exception e) {}
super.jFrame.setVisible(false);
}
public void shellSort(int delta) {
for (int i = delta; i < 100; i++) {
if (array.get(i) < array.get(i-delta)) {
int temp = array.get(i);
//子序列内排序--subsequent sort
int j;
for (j = i-delta; j>=0 && temp < array.get(j); j-=delta) {
array.set(array.get(j), j+delta);
//重画--redraw
try {
Thread.sleep(10);
} catch (Exception e) {}
repaint();
}
array.set(temp, j+delta);
}
}
}
}
QuickSort类（快速排序）
/**
* 交换类排序--快速排序(exchange sort--quick sort)
* */
public class QuickSort extends VisibleSort{
Thread thread;
QuickSort(){
thread = new Thread(this);
thread.start();
}
@Override
public void run() {
try {
startSort();
} catch (Exception e) {}
}
@Override
public void startSort() {
int low = 0;
int high = 99;
try {
Thread.sleep(1000);
} catch (Exception e) {}
QuickSort(low,high);
//2s后隐藏
try {
Thread.sleep(3000);
} catch (Exception e) {}
super.jFrame.setVisible(false);
}
public void QuickSort(int low ,int high) {
if (low < high) {
int pos = QKSort(low, high);
QuickSort(low,pos-1); //对左部子表排序
QuickSort(pos+1,high); //对右部子表排序
}
}
public int QKSort(int low,int high) {
int temp = array.get(low); //基准记录
while(low < high) {
while(low < high && array.get(high) >= temp) {
high--; //high从右向左找小于temp的数
}
if (low < high) { array.set(array.get(high), low); low++;}//找到放入左边“空位置”，此时右边有空位置
while(low < high && array.get(low) <= temp) {
low++; //low从左向右找大于temp的数
}
if(low < high) {array.set(array.get(low), high);high--;}//找到放入右边
//重画--redraw
try {
Thread.sleep(10);
} catch (Exception e) {}
repaint();
}
array.set(temp, low);//最后中间 low==high为空位置
return low; //返回基准记录的位置
}
}
BinarySort类（折半插入排序）
/**
* 插入排序---折半插入排序(insert sort---BinarySort)
* */
public class BinarySort extends VisibleSort{
Thread thread;
BinarySort(){
thread = new Thread(this);
thread.start();
}
@Override
public void run() {
while(true) {
try {
startSort();
} catch (Exception e) {
System.err.println("错误!");
}
}
}
@Override
public void startSort() {
try {
Thread.sleep(500);
} catch (Exception e) {}
for (int i = 1; i < 100; i++) {
int temp = super.array.get(i);
int low = 0;
int high = i - 1;
while(low <= high) { //确定插入位置
int mid = (low + high)/2;
if (temp < array.get(mid)) {
high = mid - 1;
}else {
low = mid + 1;
}
}
//移动,插入
for (int j = i-1; j >= low; j--) {
array.set(array.get(j), j+1);
try {
Thread.sleep(10);
} catch (Exception e) {}
repaint();
}
array.set(temp, low);
}
}
}
SelectSort（简单选择排序）
public class SelectSort extends VisibleSort{
Thread thread;
SelectSort(){
thread = new Thread(this);
thread.start();
}
@Override
public void run() {
while(true) {
try {
startSort();
} catch (Exception e) {}
}
}
@Override
public void startSort() {
int k;
//每次找一个最小的放到前面
for (int i = 0; i < 100; i++) {
k = i;
//找最小的数
for (int j = i+1; j < 100; j++) {
if (array.get(j) < array.get(k)) {
k = j;
}
}
//交换位置
if (k != i) {
int temp = array.get(i);
array.set(array.get(k), i);
array.set(temp, k);
}
//重画--redraw
try {
Thread.sleep(10);
} catch (Exception e) {}
repaint();
}
//悬停2s隐藏---hiding after 2s
try {
Thread.sleep(2000);
} catch (Exception e) {}
super.jFrame.setVisible(false);
}
}