数据结构排序功能(菜单用GUI实现)Java版
程序员文章站
2022-04-27 10:38:48
提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档文章目录前言一、程序的总体思路二、使用步骤1.引入库2.读入数据总结前言小编由于期末考试,太忙了,所以最近没有更新,希望谅解。本次针对小编结课实训写的一个简单排序程序作为讲解,主要是排序的五种方式和Java图形界面的运用,适合初学者理解排序算法、GUI、事件处理、以及面向对象的思想。一、程序的总体思路该城西二、使用步骤1.引入库代码如下(示例):import numpy as npimport pandas as...
文章目录
前言
小编由于期末考试,太忙了,所以最近没有更新,希望谅解。本次针对小编结课实训写的一个简单排序程序作为讲解,主要是排序的五种方式和Java图形界面的运用,适合初学者理解排序算法、GUI、事件处理、以及面向象的编程思想。一、程序的总体思路
这里简单介绍一下该程序的主体框架,主要分为两部分,第一部分是排序算法,第二部分是菜单的图形的实现。下面具体介绍:
二、五种排序算法
1.冒泡排序算法
- 算法的实现思路
- 比较大小
- 交换位置
- 代码实现
public int[] bubbleSort(int[] array) {
// 如果为数组为空返回原数组
if (array.length == 0)
return array;
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array.length - 1 - i; j++)
// 找到大的值交换
if (array[j + 1] < array[j]) {
swap(array, j, j + 1);
}
Display(array);
}
return array;
}
2.简单选择排序
- 算法实现思路
- 假设一个最小值
- 依次比较找到最小值记录下标
- 交换待排数与最小值
- 代码实现
public int[] selectionSort(int[] array) {
if (array.length == 0)
return array;
for (int i = 0; i < array.length; i++) {
int minIndex = i;
for (int j = i; j < array.length; j++) {
if (array[j] < array[minIndex]) // 找到最小的数
minIndex = j; // 将最小数的索引保存
}
swap(array, minIndex, i);
Display(array);
}
return array;
}
3.直接插入排序
- 算法实现思路
- 寻找插入位置
- 将待插入位置及后面的依次向后移动
- 将待排元素插入
- 代码实现
public int[] insertionSort(int[] array) {
if (array.length == 0)
return array;
int current;
for (int i = 0; i < array.length - 1; i++) {
// 记录待排的数
current = array[i + 1];
int preIndex = i;
while (preIndex >= 0 && current < array[preIndex]) {
array[preIndex + 1] = array[preIndex];
preIndex--;
}
array[preIndex + 1] = current;
Display(array);
}
return array;
}
4.折半插入排序
- 算法实现思路
- 记录上、下、及待排坐标位置
- 循环比较待排数与中间位置元素的大小缩小查找范围
- 找到插入位置,插入待排元素
- 代码实现
public int[] binaryInsertSort(int[] array) {
for (int i = 1; i < array.length; i++) {
if (array[i] < array[i - 1]) {
// 缓存i处的元素值
int tmp = array[i];
// 记录搜索范围的左边界下标
int low = 0;
// 记录搜索范围的右边界下标
int high = i - 1;
while (low <= high) {
// 记录中间位置下标
int mid = (low + high) / 2;
// 比较中间位置数据和i处数据大小,以缩小搜索范围
if (array[mid] < tmp) {
low = mid + 1;
} else {
high = mid - 1;
}
}
// 将low~i处数据整体向后移动1位
for (int j = i; j > low; j--) {
array[j] = array[j - 1];
}
// 将待排数插入
array[low] = tmp;
Display(array);
}
}
return array;
}
5.希尔排序
- 算法实现思路
- 确定步长
- 中间开始外层循环向后,内层循环向前
- 按大小交换位置
- 缩小步长
- 代码实现
public int[] ShellSort(int[] array) {
int len = array.length;
int temp, gap = len / 2;// 步长每次减半
while (gap > 0) {
//从中间开始
for (int i = gap; i < len; i++) {
temp = array[i];
//记录前一个步长位置
int preIndex = i - gap;
while (preIndex >= 0 && array[preIndex] > temp) {
array[preIndex + gap] = array[preIndex];
preIndex -= gap;
}
array[preIndex + gap] = temp;
}
gap /= 2;
Display(array);
}
return array;
}
三、菜单界面实现
总体思路很简单,菜单实现类继承JFrame类,设置窗体属性,添加设置好的面板。为更好的体现面向对象的思想,将面板也建立一个单独的类,在类体内实现各个面板并添加个组件。给组件设置监听器,为事件响应也建立一个单独的类,实现ActionListener接口,设置相对应的响应事件。
简单看一下效果,背景图片是我们宿舍楼。
1.面板类
- 按钮组件
以“冒泡排序”按钮为例
Button bubbleSort = new Button("冒泡排序");
//设置字体 字号
bubbleSort.setFont(new Font("宋体", 0, 13));
- 文本框组件
//创建文本框
JTextField inputTextField = new JTextField(20);
- 标签组件
JLabel label = new JLabel("输入数字以逗号分开");
2.窗口事件
主要实现WindowListener接口,对对应的事件响应进行编辑。
- 正在关闭事件
- 关闭事件
- 移出窗口事件
3.动作事件
- 按钮动作
- 文本框动作
分为两步,第一步对相应的组件添加监听器,第二步在动作响应类内编辑对应功能模块。
四、具体代码
菜单界面
package 排序.test1;
import java.awt.BorderLayout;
import javax.swing.JFrame;
public class Menu extends JFrame {
/**
* 视图窗口
*/
public Menu() {
this.setTitle("贾振宇的排序选择菜单");
// 设置窗体大小
this.setSize(450, 400);
// this.setLocationByPlatform(true);
// 显示窗口位置
this.setLocationRelativeTo(null);
//this.setLocation(300, 200);
// 窗口不能更改
this.setResizable(false);
this.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
//设置为边界布局
this.setLayout(new BorderLayout());
//下边界
this.add(PanelAll.southPanel(), BorderLayout.SOUTH);
//上边界
this.add(PanelAll.northPanel(), BorderLayout.NORTH);
//正中间
this.add(PanelAll.cenPanel(), BorderLayout.CENTER);
//显示窗口
this.setVisible(true);
}
}
面板类
package 排序.test1;
import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.FlowLayout;
import java.awt.Font;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.ScrollPaneConstants;
public class PanelAll {
public static Button bubbleSort, selectSort, insertionSort, shellSort, binaryInsertSort;
static JButton jButton;
public static JTextField inputTextField;
public static JTextArea showArea;
/**
* 中间面板
*
* @return
*/
public static JPanel cenPanel() {
//背景图片
ImageIcon image = new ImageIcon("images/qg.jpg");
//new 一个Jlabel存图片
JLabel jLabel = new JLabel(image);
//图片位置
jLabel.setBounds(0, 0, image.getIconWidth(), image.getIconHeight());
//新建一个面板
JPanel cenJPanel = new JPanel();
//边界布局
cenJPanel.setLayout(new BorderLayout());
//文本框
showArea = new JTextArea(1, 20);
showArea.setEditable(false);
//新建展示结果面板
JPanel showJPanel = new JPanel();
showJPanel.setLayout(new FlowLayout());
JLabel label = new JLabel("排序结果:");
jButton = new JButton("显示排序结果");
//设置监听器
jButton.addActionListener(new MyActionlistener());
//添加
showJPanel.add(label);
showJPanel.add(showArea);
showJPanel.add(jButton);
//滚动面板
JScrollPane jScrollPane = new JScrollPane();
//显示方式
jScrollPane.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
jScrollPane.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED);
jScrollPane.setViewportView(showJPanel);
//添加位置
cenJPanel.add(jScrollPane, BorderLayout.SOUTH);
cenJPanel.add(jLabel, BorderLayout.NORTH);
return cenJPanel;
}
/**
* 下方面板
*
* @return
*/
public static JPanel southPanel() {
//创建文本框
inputTextField = new JTextField(20);
//创建面板
JPanel southPanel = new JPanel();
southPanel.setLayout(new FlowLayout());
JLabel label = new JLabel("输入数字以逗号分开");
JButton btnButton = new JButton("确定");
//设置监听器
btnButton.addActionListener(new MyActionlistener());
southPanel.add(label);
southPanel.add(inputTextField);
southPanel.add(btnButton);
return southPanel;
}
/**
* 上方面板
*
* @return
*/
public static JPanel northPanel() {
JPanel northPanel = new JPanel();
northPanel.setLayout(new FlowLayout());
//建立按钮 与监听
bubbleSort = new Button("冒泡排序");
//设置字体 字号
bubbleSort.setFont(new Font("宋体", 0, 13));
bubbleSort.addActionListener(new MyActionlistener());
selectSort = new Button("简单选择排序");
selectSort.addActionListener(new MyActionlistener());
insertionSort = new Button("直接插入排序");
insertionSort.addActionListener(new MyActionlistener());
shellSort = new Button("希尔排序");
shellSort.addActionListener(new MyActionlistener());
binaryInsertSort = new Button("折半插入排序");
binaryInsertSort.addActionListener(new MyActionlistener());
northPanel.add(bubbleSort);
northPanel.add(selectSort);
northPanel.add(insertionSort);
northPanel.add(binaryInsertSort);
northPanel.add(shellSort);
return northPanel;
}
}
动作事件类
package 排序.test1;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;
/**
* 事件处理类
*
* @author zhenyu
*
*/
public class MyActionlistener implements ActionListener {
// 静态数组用于储存数据
static int array[];
public void actionPerformed(ActionEvent e) {
SortAll sortAll = new SortAll();
if (e.getActionCommand().equals("确定")) {
// 获取字符串
String text = PanelAll.inputTextField.getText();
// 解析字符串
String[] split = text.split(",");
Integer valueOf;
array = new int[split.length];
for (int i = 0; i < split.length; i++) {
valueOf = Integer.valueOf(split[i]);
// System.out.println(valueOf);
array[i] = valueOf;
}
System.out.println("解析成功!");
PanelAll.inputTextField.setText("");
}
// 五种排序按钮的触发事件
if (e.getActionCommand().equals("冒泡排序")) {
System.out.println("下面是冒泡排序");
int[] copyArray = Arrays.copyOfRange(array, 0, array.length);
long statr = System.currentTimeMillis();
sortAll.bubbleSort(copyArray);
long end = System.currentTimeMillis();
System.out.println("冒泡排序用时:" + (end - statr) + "ms");
System.out.println("========================================");
}
if (e.getActionCommand().equals("简单选择排序")) {
System.out.println("下面是选择排序");
int[] copyArray = Arrays.copyOfRange(array, 0, array.length);
long statr = System.currentTimeMillis();
sortAll.selectionSort(copyArray);
long end = System.currentTimeMillis();
System.out.println("简单选择排序用时:" + (end - statr) + "ms");
System.out.println("========================================");
}
if (e.getActionCommand().equals("直接插入排序")) {
System.out.println("下面是直接插入排序");
int[] copyArray = Arrays.copyOfRange(array, 0, array.length);
long statr = System.currentTimeMillis();
sortAll.insertionSort(copyArray);
long end = System.currentTimeMillis();
System.out.println("直接插入排序用时:" + (end - statr) + "ms");
System.out.println("========================================");
}
if (e.getActionCommand().equals("希尔排序")) {
System.out.println("下面是希尔排序");
int[] copyArray = Arrays.copyOfRange(array, 0, array.length);
long statr = System.currentTimeMillis();
sortAll.ShellSort(copyArray);
long end = System.currentTimeMillis();
System.out.println("希尔排序用时:" + (end - statr) + "ms");
System.out.println("========================================");
}
if (e.getActionCommand().equals("折半插入排序")) {
System.out.println("下面是折半插入");
int[] copyArray = Arrays.copyOfRange(array, 0, array.length);
long statr = System.currentTimeMillis();
sortAll.binaryInsertSort(copyArray);
long end = System.currentTimeMillis();
System.out.println("折半排序用时:" + (end - statr) + "ms");
System.out.println("========================================");
}
if (e.getActionCommand().equals("显示排序结果")) {
PanelAll.showArea.setText("");
int[] copyArray = Arrays.copyOfRange(array, 0, array.length);
int[] sortF = sortAll.sortF(copyArray);
for (int i = 0; i < sortF.length; i++) {
PanelAll.showArea.append(String.valueOf(sortF[i]) + " ");
}
// PanelAll.jButton.setEnabled(false);
System.out.println("显示完成!");
}
}
}
窗口事件
package 排序.test1;
import java.awt.Button;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import javax.swing.JDialog;
public class MyWindowListener implements WindowListener {
private Menu menu;
public MyWindowListener(Menu menu2) {
// TODO Auto-generated constructor stub
menu = menu2;
}
@Override
public void windowOpened(WindowEvent e) {
// TODO Auto-generated method stub
System.out.println("欢迎来到这里!");
System.out.println("下面是排序综合算法的设计与实现的展示:");
}
@Override
public void windowClosing(WindowEvent e) {
// TODO Auto-generated method stub
close(this.menu);
}
@Override
public void windowClosed(WindowEvent e) {
// TODO Auto-generated method stub
}
@Override
public void windowIconified(WindowEvent e) {
// TODO Auto-generated method stub
}
@Override
public void windowDeiconified(WindowEvent e) {
// TODO Auto-generated method stub
}
@Override
public void windowActivated(WindowEvent e) {
// TODO Auto-generated method stub
}
@Override
public void windowDeactivated(WindowEvent e) {
// TODO Auto-generated method stub
}
public void close(Menu menu) {
JDialog jDialog = new JDialog(menu, "关闭", true);
jDialog.setSize(200, 200);
jDialog.setLocationRelativeTo(null);
jDialog.setLayout(new FlowLayout(FlowLayout.CENTER, 50, 20));
jDialog.setDefaultCloseOperation(JDialog.HIDE_ON_CLOSE);
Button yButton = new Button("是");
Button nButton = new Button("否");
jDialog.add(yButton);
jDialog.add(nButton);
yButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
System.out.println("确定关闭!");
System.exit(0);
}
});
nButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
jDialog.setVisible(false);
jDialog.dispose();
System.out.println("误操作!");
}
});
jDialog.setVisible(true);
}
}
五种排序
package 排序.test1;
public class SortAll {
/**
* 交换数组内两个元素
* @param array
* @param i
* @param j
*/
public static void swap(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
/*
* 冒泡排序
*/
public int[] bubbleSort(int[] array) {
// 如果为数组为空返回原数组
if (array.length == 0)
return array;
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array.length - 1 - i; j++)
// 找到大的值交换
if (array[j + 1] < array[j]) {
swap(array, j, j + 1);
}
Display(array);
}
return array;
}
/*
* 简单选择排序
*/
public int[] selectionSort(int[] array) {
if (array.length == 0)
return array;
for (int i = 0; i < array.length; i++) {
int minIndex = i;
for (int j = i; j < array.length; j++) {
if (array[j] < array[minIndex]) // 找到最小的数
minIndex = j; // 将最小数的索引保存
}
swap(array, minIndex, i);
Display(array);
}
return array;
}
/*
* 直接插入
*/
public int[] insertionSort(int[] array) {
if (array.length == 0)
return array;
int current;
for (int i = 0; i < array.length - 1; i++) {
// 记录待排的数
current = array[i + 1];
int preIndex = i;
while (preIndex >= 0 && current < array[preIndex]) {
array[preIndex + 1] = array[preIndex];
preIndex--;
}
array[preIndex + 1] = current;
Display(array);
}
return array;
}
/*
* 折半插入
*/
public int[] binaryInsertSort(int[] array) {
for (int i = 1; i < array.length; i++) {
if (array[i] < array[i - 1]) {
// 缓存i处的元素值
int tmp = array[i];
// 记录搜索范围的左边界下标
int low = 0;
// 记录搜索范围的右边界下标
int high = i - 1;
while (low <= high) {
// 记录中间位置下标
int mid = (low + high) / 2;
// 比较中间位置数据和i处数据大小,以缩小搜索范围
if (array[mid] < tmp) {
low = mid + 1;
} else {
high = mid - 1;
}
}
// 将low~i处数据整体向后移动1位
for (int j = i; j > low; j--) {
array[j] = array[j - 1];
}
// 将待排数插入
array[low] = tmp;
Display(array);
}
}
return array;
}
/*
* 希尔排序
*/
public int[] ShellSort(int[] array) {
int len = array.length;
int temp, gap = len / 2;// 步长每次减半
while (gap > 0) {
//从中间开始
for (int i = gap; i < len; i++) {
temp = array[i];
//记录前一个步长位置
int preIndex = i - gap;
while (preIndex >= 0 && array[preIndex] > temp) {
array[preIndex + gap] = array[preIndex];
preIndex -= gap;
}
array[preIndex + gap] = temp;
}
gap /= 2;
Display(array);
}
return array;
}
/*
* 显示数组
*/
public void Display(int[] array) {
int i = 0;
for (i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}
public int[] sortF(int[] array) {
if (array.length == 0)
return array;
for (int i = 0; i < array.length; i++) {
int minIndex = i;
for (int j = i; j < array.length; j++) {
if (array[j] < array[minIndex]) // 找到最小的数
minIndex = j; // 将最小数的索引保存
}
swap(array, minIndex, i);
}
return array;
}
}
五、效果图
总结
本次主要是针对本学期所学的简单应用,主要涉及排序算法、GUI图形界面、字符串的处理、以及一些常用类的调用。面向对象的思想是需要我们自己去体会理解的,在这里我想提醒大家,主动去练习,多动手才可以更好的理解。文章看起来很长,主要是加了很多源代码,这也是我在查询资料时有时遇到的问题,不愿去下载东西,所以就附源码。
如果想要打包好的,请在下方留言。
欢迎大家点赞评论!
本文地址:https://blog.csdn.net/weixin_47547146/article/details/111658122