python 可视化 不同排序_Python可视化排序算法

【作者简介】

冒绿光的盒子，公众号投稿作者，个人简书主页：https://www.jianshu.com/u/cbacf40d927f。

排序可视化

SelectionSort

选择排序很简单，所有的排序算法在前面的博客都有讲解：

https://www.jianshu.com/p/7fbf8671c742

选择排序很简单，遍历所有元素，查看一下他们的之后最小的元素和当前元素交换即可。模板函数使用上面的swing模板。为了更清楚显示出排序的过程，可以用不同颜色代表排好序和未排好序的。

int w = canvasWidth / data.N();

AlgorithmHelper.setColor(graphics2D, AlgorithmHelper.LightBlue);

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

if (i < data.orderIndex) {

AlgorithmHelper.setColor(graphics2D, AlgorithmHelper.Red);

} else {

AlgorithmHelper.setColor(graphics2D, AlgorithmHelper.Grey);

}

if (i == data.currentIndex) {

AlgorithmHelper.setColor(graphics2D, AlgorithmHelper.Indigo);

}

if (i == data.currentComperent) {

AlgorithmHelper.setColor(graphics2D, AlgorithmHelper.LightBlue);

}

AlgorithmHelper.fillRectangle(graphics2D, i * w, canvasHeight - data.get(i), w - 1, data.get(i));

}

}

Frame的画图函数主要构成部分，其余的都是模板，为了抽象性，所以把selection的数据集中起来形成一个新的类，包括了生成数据等等。

public class SelectionSortData {

private int[] numbers;

public int orderIndex = -1;

public int currentIndex = -1;

public int currentComperent = -1;

public SelectionSortData(int N, int randomBound) {

numbers = new int[N];

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

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

//System.out.println(numbers[i]);

}

}

public void setData(int orderIndex, int currentComperent, int currentIndex){

this.currentIndex = currentIndex;

this.currentComperent = currentComperent;

this.orderIndex = orderIndex;

}

public int N(){

return numbers.length;

}

public int get(int index){

if (index < 0 || index >= numbers.length){

throw new IllegalArgumentException("index is illgel!");

}

return numbers[index];

}

public void swap(int i, int j){

int t = numbers[i];

numbers[i] = numbers[j];

numbers[j] = t;

}

}

在这个数据类里面有三个属性，分别是已经排好序的索引，当前最小值，当前正在比较的索引。在渲染过程中需要改变就是这几个颜色了。所以动态的效果主要来源就是通过改变着几个值即可。

private void run() {

data.setData(0,-1,-1);

frame.render(data);

AlgorithmHelper.pause(DELAY);

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

int midIndex = i;

data.setData(i, -1, midIndex);

frame.render(data);

AlgorithmHelper.pause(DELAY);

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

data.setData(i, j, midIndex);

frame.render(data);

AlgorithmHelper.pause(DELAY);

if (data.get(j) < data.get(midIndex)){

midIndex = j;

data.setData(i, j, midIndex);

frame.render(data);

AlgorithmHelper.pause(DELAY);

}

}

data.swap(i, midIndex);

data.setData(i+1, -1, -1);

frame.render(data);

AlgorithmHelper.pause(DELAY);

}

data.setData(data.N(), -1,-1);

frame.render(data);

AlgorithmHelper.pause(DELAY);

}

查看一下效果：

InsertionSort

插入排序也很简单，没有涉及到递归操作等等。每遍历一个元素，看看这个元素和之前比较过的位置是在那里，像打牌的时候插排一样。和之前的查找一样，已经排好序的位置就直接用红色表示，当前对比位置用蓝色表示。首先是画图paintComponent：

int w = canvasWidth / data.N();

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

if (i < data.orderIndex){

AlgorithmHelper.setColor(graphics2D, AlgorithmHelper.Red );

}else {

AlgorithmHelper.setColor(graphics2D, AlgorithmHelper.Grey);

}

if (i == data.currentIndex){

AlgorithmHelper.setColor(graphics2D, AlgorithmHelper.LightBlue);

}

AlgorithmHelper.fillRectangle(graphics2D, i * w, canvasHeight - data.get(i), w - 1, data.get(i));

}

}

和上面的选择排序差不多。

private void run() {

setData(-1, -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(i, -1);

}

setData(data.N(), -1);

}

private void setData(int orderIndex, int currentIndex){

data.orderIndex = orderIndex;

data.currentIndex = currentIndex;

frame.render(data);

AlgorithmHelper.pause(DELAY);

}

都是常规操作。

MergeSort

归并排序本身的思路，面对一个数组想要让他排序，首先把数组分成两部分，用同样的算法把两边排序，最后归并两边。在划分的时候，划分到不能再划分为止。首先同样要有一个归并的数据类：

public class MergeData {

private int[] numbers;

public int l, r;

public int mergeIndex;

public MergeData(int N, int randomBound) {

numbers = new int[N];

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

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

//System.out.println(numbers[i]);

}

}

public int N(){

return numbers.length;

}

public int get(int index){

if (index < 0 || index >= numbers.length){

throw new IllegalArgumentException("index is illgel!");

}

return numbers[index];

}

public void set(int index, int num){

if (index < 0 || index >= numbers.length){

throw new IllegalArgumentException("index is illgel!");

}

numbers[index] = num;

}

public void swap(int i, int j){

int t = numbers[i];

numbers[i] = numbers[j];

numbers[j] = t;

}

}

用l和r来表示正在归并的数组范围，mergeIndex表示已经进行归并了的集合。归并整个过程前面的博客有写，不再复述了。

private void run() {

setData(-1, -1, -1 );

Merge(0, data.N()-1);

setData(0, data.N()-1, -1);

}

private void Merge(int l, int r) {

if (l >= r) {

return;

}

setData(l, r, -1);

int mid = (l + r) / 2;

Merge(l, mid);

Merge(mid + 1, r);

merge(l, r, mid);

}

private void merge(int l, int r, int mid) {

int[] array = new int[r - l + 1];

for (int i = l; i <= r; i++) {

array[i - l] = data.get(i);

}

int i = l, j = mid + 1;

int index = l;

while (i <= mid && j <= r) {

if (array[i - l] < array[j - l]) {

data.set(index, array[i - l]);

i++;

index++;

} else {

data.set(index, array[j - l]);

j++;

index++;

}

setData(l, r, index);

}

if (i <= mid) {

for (int k = i; k <= mid; k++) {

data.set(index, array[k - l]);

index++;

setData(l, r, index);

}

} else if (j <= r) {

for (int k = j; k <= r; k++) {

data.set(index, array[k - l]);

index++;

setData(l, r, index);

}

}

}

效果：

QuickSort

快速排序，快速排序是在平均情况下比较快的算法了。每一次把第一个元素作为标定的位置，把这个位置放到合适的位置即可。首先还是需要一个快拍数据类：

public class QuickSortData {

private int[] numbers;

public int l, r;

public int Index;

public QuickSortData(int N, int randomBound) {

numbers = new int[N];

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

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

//System.out.println(numbers[i]);

}

}

public int N(){

return numbers.length;

}

public int get(int index){

if (index < 0 || index >= numbers.length){

throw new IllegalArgumentException(index + "index is illgel!");

}

return numbers[index];

}

public void set(int index, int num){

if (index < 0 || index >= numbers.length){

throw new IllegalArgumentException("index is illgel!");

}

numbers[index] = num;

}

public void swap(int i, int j){

int t = numbers[i];

numbers[i] = numbers[j];

numbers[j] = t;

}

}

和前面的归并排序一样，l和r用不同的颜色。

private void run() {

setData(-1, -1, -1);

QuickSort(0, data.N() - 1);

setData(0, data.N() - 1, -1);

}

private void QuickSort(int l, int r) {

if (l >= r) {

return;

}

setData(l, r, -1);

int mid = partition(l, r);

QuickSort(l, mid - 1);

QuickSort(mid + 1, r);

frame.render(data);

AlgorithmHelper.pause(DELAY);

}

private int partition(int l, int r) {

int v = data.get(l);

int i = l + 1;

int j = r;

setData(l, r, l);

while (true) {

while (i <= r && data.get(i) < v) {

i++;

}

while (j >= l + 1 && data.get(j) > v) {

j--;

}

if (i > j) {

break;

}

data.swap(i, j);

setData(l, r, l);

i++;

j--;

}

data.swap(j, l);

setData(l, r, j);

return j;

}

和前面基本一致。

|今日打卡主题

第n天打卡，你熟悉的排序算法有哪些？留言写出来(希望大家走心打卡，让意见纠正传播)

| 推荐阅读

Python来看啥是佩奇

我爬取了人人都是产品经理6574篇文章，发现产品经理竟然在看这些

Python骚操作：用Python来PS

2019，我们一起让知识『好看』

来源：51CTO

作者：mb5fe94bf10ac65

链接：https://blog.51cto.com/15069482/2578545