java实现一个选择、冒泡、插入排序的简单演示器

介绍

 用javafx工具做了一个简单演示器，可以自己输入整数序列，然后查看不同排序方式的排序过程（这里做的是选择排序、插入排序及冒泡排序）

界面

左侧单选框表示使用选择排序、插入排序或冒泡排序

下方文本框输入一个整数，点击"Add"完成一次添加；

多次添加，完成序列输入后，点击"Next"，可一步一步查看相应的排序过程

实现

这里用javafx做的界面

主要思路

一个整数线性表存储数据，另有一（等长的）一个文本域线性表，文本域线性表的i元素（一个文本域）用来显示数据线性表的i元素（一个整数），姑且称为文本域线性表与整数线性表的“关联”。排序过程中的每一步相当于将整数线性表中数据位置更新，此时将“关联”刷新一次，就可以由文本域线性表在界面显示整数线性表中每个数据更新后的位置。

排序的函数作了一点变化，将正常的排序函数里for(i)，for(j)循环去掉，改为手动变更i, j的值，以便“一步一步”地查看排序过程。

排序面板（ListPane）

排序面板（我命名为ListPane类）用于显示数据，ListPane类里定义一个私有的文本域线性表numberList（ArrayList类)，这个线性表存储的数据类型为文本域TextArea类。另外定义四个公共函数 添加数据(addNumber() )、更新线性表(renewNumberList() )、显示线性表(showNumberList() )、清空线性表（clearNumberList() ）

添加数据(addNumber() )函数：形参为整数n。调用这个函数时，创建一个显示整数n的文本域TextArea对象，之后将这个文本域对象添加到文本域线性表numberList中

更新线性表(renewNumberList）函数：形参为整数线性表numbers。调用这个函数时，将文本域线性表numberList清空，然后为numbers里的每个整数调用一次addNumber()函数，即为numberList中每个整数创建一个文本域并加入到文本域线性表numberList中，以实现上述的关联、刷新。

显示线性表(showNumberList)函数：无形参。调用这个函数时，显示面板显示当前的文本域线性表numberList中的内容。

清空线性表（clearNumberList()）函数：无形参。调用这个函数时，清空文本域线性表clearNumberList。

主面板（ShowSort）

主面板含一个排序面板类ListPane的对象，此外增加了单选框（用于选择排序方法）、输入框、控制按钮，以及一个整数线性表。

当选择单选框的不同方法时，私有变量method取不同的标识。

当添加整数时，一方面将这个整数添加到整数线性表中，另一方面调用LispPane对象的addNumber()函数和showNumberList()函数，以显示目前已添加的数据。

当点击"Next"时，根据method标识，调用相应的排序函数进行一步排序操作，之后调用ListPane对象的renewNumberList()函数和showNumberList()函数，以显示一步排序操作后的数据。

当点击"Clear"时，情况整数线性表，调用ListPane对象的clearNumberList()函数和showNumberList()函数。

代码

排序面板ListPane

package show_sort;

import java.util.ArrayList;
import javafx.scene.control.TextArea;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;

class ListPane extends BorderPane {
	private ArrayList<TextArea> numberList = new ArrayList<>();
	private HBox hBox = new HBox();
	
	public ListPane() {
		setCenter(hBox);
	}
	
	// addNumber()
	public void addNumber(Integer n) {
		TextArea ta = new TextArea();
		ta.setEditable(false);
		ta.setMaxWidth(30);
		ta.setMaxHeight(30);
		ta.setText(n.toString());
		numberList.add(ta);
	}
	
	// renewNumberList()
	public void renewNumberList(ArrayList<Integer> numbers) {
		numberList.clear();
		for(int i = 0; i < numbers.size(); i++) {
			addNumber(numbers.get(i));
		}			
	}
	
	// showNumberList()
	public void showNumberList() {
		hBox.getChildren().clear();
		for(TextArea ta: numberList) {
			hBox.getChildren().add(ta);
		}
	}
	
	// clearNumberList()
	public void clearNumberList() {
		numberList.clear();
	}
}

主面板ShowSort

package show_sort;

import javafx.application.Application;
import javafx.scene.control.Button;
import javafx.scene.Scene;
import javafx.scene.layout.HBox;
import javafx.scene.layout.VBox;
import javafx.scene.control.TextField;
import javafx.scene.control.RadioButton;
import javafx.scene.control.ToggleGroup;
import javafx.scene.text.Text;
import javafx.stage.Stage;
import java.util.ArrayList;

public class ShowSort extends Application {
	private Text text = new Text("Input an integer");
	private TextField tfInput = new TextField();
	private Button btAdd = new Button("Add");
	private Button btNext = new Button("Next");
	private Button btClear = new Button("Clear");
	private String method = new String();
	private ListPane pane = new ListPane();
	private ArrayList<Integer> numberList = new ArrayList<>();
	private int i;
	private int j;
	private boolean next = true;	
	private Integer current;
	
	@Override
	public void start(Stage primaryStage) {
		// UI
		HBox hBox = new HBox();
		hBox.getChildren().addAll(text, tfInput, btAdd,
				btNext, btClear);
		pane.setBottom(hBox);
		
		RadioButton rbSelect = new RadioButton("Select");
		RadioButton rbInsert = new RadioButton("Insert");
		RadioButton rbBubble = new RadioButton("Bubbule");
		VBox vBox = new VBox();
		vBox.getChildren().addAll(rbSelect, rbInsert, rbBubble);
		pane.setLeft(vBox);
		
		ToggleGroup tg = new ToggleGroup();
		rbSelect.setToggleGroup(tg);
		rbInsert.setToggleGroup(tg);
		rbBubble.setToggleGroup(tg);
		
		Scene scene = new Scene(pane, 1000, 150);
		primaryStage.setTitle("Sort");
		primaryStage.setScene(scene);
		primaryStage.show();
		
		// Click Button
		btAdd.setOnAction(e -> addAction());
		btNext.setOnAction(e -> nextAction());
		btClear.setOnAction(e -> clearAction());
		
		// Chose sort method
		rbSelect.setOnAction(e -> {
			if(rbSelect.isSelected()) {
				method = "select";
				initialIJ();
			}
		});
		rbInsert.setOnAction(e -> {
			if(rbInsert.isSelected()) {
				method = "insert";
				initialIJ();
			}
		});
		rbBubble.setOnAction(e -> {
			if(rbBubble.isSelected()) {
				method = "bubble";
				initialIJ();
			}
		});
			
	}
	
	// Action when click 'Add'
	public void addAction() {
		Integer input = Integer.parseInt(tfInput.getText());
		if(input instanceof Integer) {
			pane.addNumber(input);
			pane.showNumberList();
			numberList.add(input);
			tfInput.clear();
		}
	}
	
	// Action when click 'Clear'
	public void clearAction() {
		pane.clearNumberList();
		pane.showNumberList();
		numberList.clear();
		tfInput.clear();
		initialIJ();
		next = true;
	}
	
	// Action when click 'Next'
	public void nextAction() {
		next = true;
		sortMethod(numberList, method);
		pane.renewNumberList(numberList);
		pane.showNumberList();
	}	
	
	public void initialIJ() {
		switch(method) {
			case "select":
				i = 0;
				j = 1;
				break;
			case "insert":
				i = 0;
				j = 0;
				break;
			case "bubble":
				i = 0;
				j = 0;
				break;
		}
	}
	
	// Call relative sort function
	public void sortMethod(ArrayList<Integer> numbers, 
			String method) {
		switch(method) {
			case "select":
				selectOnce(numbers);
				break;
			case "insert":
				insertOnce(numbers);
				break;
			case "bubble":
				bubbleOnce(numbers);
				break;
		}
	}
	
	// Insert sort function
	public void insertOnce(ArrayList<Integer> numbers) {
		int n = numbers.size();
		while(next && i < n) {
			if(i - j <= 1) {
				current = numbers.get(i);
			}
			while(next && j > -1) {
				if(current < numbers.get(j)) {
					numbers.set(j + 1, numbers.get(j));
					numbers.set(j, current);
					next = false;
				}
				j -= 1;
			}
			if(j == -1) {
				i += 1;
				j = i - 1;
			}
		}
		/* Pseudo code
		n = length(number_list)
    	for i in [0, 1, ..., n-1]:
        	current = number_list[i]
        	for j in [i-1, i-2, ..., -1]:
            	if current < number_list[j]:
                	number_list[j + 1] = number_list[j]
                	number_list[j] = current
		*/
	}
	
	// Select sort function 
	public void selectOnce(ArrayList<Integer> numbers) {
		int n = numbers.size();
		while(next && i < n) {
			while(next && j < n) {
				if(numbers.get(j) < numbers.get(i)) {
					Integer temp = numbers.get(i);
					numbers.set(i, numbers.get(j));
					numbers.set(j, temp);
					next = false;
				}
				j += 1;
			}
			if(j == n) {
				i += 1;
				j = i + 1;
			}
		}
		/* Pseudo code
		n = length(number_list)
		for i in [0, 1, ..., n-1]:
			for j in [i+1, i+2, ..., n]:
				if number_list[j] < number_list[i]:
					temp = number_list[i]
					number_list[i] = number_list[j]
					number_list[j] = temp
		*/
	}
	
	// Bubble sort function
	public void bubbleOnce(ArrayList<Integer> numbers) {
		int n = numbers.size();
		while(next && i < n - 1) {
			while(next && j < n - i - 1) {
				if(numbers.get(j) > numbers.get(j + 1)) {
					Integer temp = numbers.get(j);
					numbers.set(j, numbers.get(j + 1));
					numbers.set(j + 1, temp);
					next = false;
				}
				j += 1;
			}
			if(j == n - i - 1) {
				i += 1;
				j = 0;
			}
		}
		/* Pseudo code
    	n = length(number_list)
    	for i in [0, 1, ..., n-1]:
        	for j in [0, 1, ..., n-i-1]:
            	if number_list[j] > number_list[j + 1]:
                	temp = number_list[j]
                	number_list[j] = number_list[j + 1]
                	number_list[j + 1] = temp
		*/
	}
	
	public static void main(String[] args) {
		Application.launch(args);
	}
}