简介数据结构课程设计资源包内含两个经典Java项目手机通讯录模拟与24点扑克牌游戏覆盖链表、数组、哈希表、排序等数据结构核心应用适合高校学生完成课程设计、备战考试或巩固Java编程能力。压缩包共73个文件整体仅431KB以53张PNG运行截图为主体直观展示界面与执行结果另有5个Java源码、8个XML配置、5个class编译文件并附带IDEA工程文件与说明HTML便于导入工程对照研读。目前已有652人学习下载实用性获得认可。项目完整实现通讯录的增删查改与按姓名快速查找详细演示ArrayList、LinkedList及HashMap的典型用法24点游戏采用深度优先搜索与回溯算法穷举全部加减乘除组合帮助深入理解递归与栈机制同时涉及Set避免重复计算、优先队列优化搜索等进阶技巧。资源虽小但组织结构清晰运行截图丰富代码注释到位适合需要快速上手课程设计或系统复习数据结构知识点的读者。1. 这个课程设计项目把两座“大山”一次翻过去了数据结构课程设计最怕的题目有两个一个是通讯录模拟听着简单真写起来增删改查排序查找全都要从头实现另一个是24点扑克牌游戏算法思路谁都懂真让代码把所有解都列出来并输出算式能耗掉一礼拜。这套资源恰好把 java 数据结构 课程设计里的这两大经典题目打包在了一起用纯 Java 控制台程序实现不依赖任何框架。项目一共两个独立模块手机通讯录模拟——用自实现的顺序表完成联系人的增删改查、排序、二分查找和分组统计24点扑克牌游戏——用递归全排列加双栈表达式求值穷举所有能算出24的算式并输出。它适合两类人正在准备数据结构课设、需要参考完整源码的学生以及想把线性表、栈、递归这些抽象概念落到真实代码里的开发者。看完这篇你能照着我拆出来的代码结构把项目跑起来并改成自己的课设版本。2. 整体架构与设计两个模块如何共享一套底层代码拿到题目第一反应是“这不就两个小 Demo 吗”真动手才发现课设提交要的是完整工程菜单、输入校验、异常处理、模块划分、注释规范一样都不能少。这套资源没有用 Spring 那套重型框架而是回归原生 Java 控制台程序——数据结构课设的核心考察点是数据结构和算法的实现不是框架用法这一点设计得很务实。2.1 包结构与类职责划分整个工程按功能拆成四个包干净利落。主程序只负责菜单分发业务逻辑全部分离到具体类里这符合课程设计的评分标准里“模块化设计”这一项。src/ ├── com/course/design/ │ ├── Main.java // 主入口菜单循环 │ ├── common/ │ │ ├── InputUtil.java // 统一输入工具防数字格式异常 │ │ └── Menu.java // 菜单渲染与路由 │ ├── contacts/ │ │ ├── Contact.java // 联系人实体实现 Comparable │ │ └── ContactList.java // 顺序表实现增删改查排序查找 │ └── poker/ │ ├── Card.java // 扑克牌抽象点数、花色 │ ├── Permutation.java // 四个数字的全排列生成 │ ├── ExpressionGenerator.java // 括号模板与运算符组合 │ ├── Evaluator.java // 双栈表达式求值器 │ └── Poker24Game.java // 24点主业务逻辑这种划分的逻辑是通讯录模块考察线性表24点模块考察递归和栈。contacts包里的ContactList是自实现的顺序表没有用ArrayList偷懒——这是课程设计评分时重点检查的地方poker包里把“生成算式”和“计算算式”分成两个类前者负责纯枚举后者负责用栈求值职责互不干扰调试的时候定位问题特别方便。2.2 技术选型为什么用顺序表而不是链表或数据库通讯录模块的数据存储是在顺序表和链表之间纠结过的。顺序表的优势是随机访问快、实现简单缺点是插入删除要搬移元素链表正好相反。联系人这个场景绝大多数操作是“按姓名查找”和“展示全部”插入删除频率不高所以顺序表更合适。这样还顺便覆盖了“顺序表实现”这个课程设计考点。24点模块的存储更轻量四个数字就是int[]数组递归生成全排列时直接在数组上交换元素连额外的集合都不用。求值阶段需要后进先出的特性这里用栈——中缀表达式先转成后缀表达式再用栈计算结果一次性把“栈的应用”这个考点评分点也拿到了。2.3 输入工具与异常防御控制台程序最烦的坑是用户输入了非数字导致程序崩溃。课程设计答辩现场评委一定会拿异常输入来试你的程序。这套代码做了一个统一的InputUtil核心思路是“出错重来而不是崩溃退出”。量级不大但对课设程序的鲁棒性提升非常明显。public class InputUtil { private static final Scanner scanner new Scanner(System.in); // 读取一个 int出错自动重输入 public static int readInt(String prompt) { while (true) { System.out.print(prompt); String line scanner.nextLine().trim(); try { return Integer.parseInt(line); } catch (NumberFormatException e) { System.out.println(输入无效请重新输入整数); } } } // 读取一个字符串去掉首尾空格 public static String readLine(String prompt) { System.out.print(prompt); return scanner.nextLine().trim(); } }这个工具类被两个模块复用。readInt里用while(true)循环包住解析逻辑解析失败就提示并回到起点输入“abc”不会崩溃只会反复提醒。parseInt在 Java 里对“12abc”这种混合字符串会直接抛异常所以 catch 住就完事了。注意第 6 行 scanner 对象是静态的程序启动时创建一次避免多个实例在控制台输入时产生缓冲区错乱的问题。2.4 主菜单路由与控制流Main 类的菜单路由用了一个 switch 分发这是控制台程序最直观的做法。不做面向对象的策略模式因为课程设计阶段可读性比扩展性重要。菜单循环的退出条件是用户输入 0每次操作完成后回到主菜单不会直接退出程序——这是课设程序的“基本素养”提交的代码要能连续操作多轮。public class Main { public static void main(String[] args) { boolean running true; while (running) { int choice Menu.showMainMenu(); switch (choice) { case 1 - new ContactApp().run(); // 通讯录模块 case 2 - new Poker24Game().run(); // 24点模块 case 0 - { System.out.println(程序退出感谢使用); running false; } default - System.out.println(无效选项请重新选择); } } } }这里case 1和case 2的写法是 Java 14 之后的箭头语法如果学校的编译环境是 Java 8要改成传统的case 1: ... break;形式。每个模块的run()方法内部自己维护二级菜单循环主菜单只负责“进哪个模块”不做业务处理。这样的层级关系答辩时画一个程序流程图就能说清楚整体控制流。3. 通讯录模块核心拆解一个联系人的完整生命周期通讯录模块的考察点集中在ContactList这个顺序表实现上。这里有一个课设评分认可的常见做法联系人实体Contact实现Comparable接口把“按什么排序”的逻辑内聚到实体自己身上排序方法只负责比较器的调用这样后面扩展按电话排序时改一行代码就能搞定。3.1 联系人实体与比较规则Contact是一个典型的 POJO字段包括姓名、电话、分组、备注外加一个compareTo方法。排序默认按姓名走字典序这样Collections.sort或者手写排序直接用实体自身的比较规则即可。public class Contact implements ComparableContact { private String name; // 姓名 private String phone; // 电话号码 private String group; // 分组家人/朋友/同事 private String remark; // 备注 Override public int compareTo(Contact o) { // 姓名相同再比较电话号码保证排序稳定性 int cmp this.name.compareTo(o.name); if (cmp ! 0) return cmp; return this.phone.compareTo(o.phone); } }compareTo里先比姓名再比电话这个“二级排序键”的设计避免了一个实际问题通讯录里存在同名联系人时只按姓名排序会导致顺序不稳定。注意第 6 行compareTo返回的是字典序差值不是简单返回 0 或 1因为sort依赖这个返回值的正负号来判断谁前谁后。3.2 顺序表扩容、插入与删除ContactList底层用一个Contact[]数组存数据size记录当前有效元素个数。扩容的时机是在插入前判断数组满了就翻倍扩容。这一套逻辑手写的时候最容易漏“数组越界”的边界情况。public class ContactList { private Contact[] data; // 底层数组 private int size; // 当前元素个数 private static final int DEFAULT_CAPACITY 10; public ContactList() { data new Contact[DEFAULT_CAPACITY]; size 0; } // 扩容数组长度翻倍旧数据搬移 private void ensureCapacity() { if (size data.length) { Contact[] newData new Contact[data.length * 2]; System.arraycopy(data, 0, newData, 0, size); data newData; } } // 尾部添加 public void add(Contact c) { ensureCapacity(); data[size] c; } // 按下标删除后面元素依次前移 public Contact remove(int index) { if (index 0 || index size) { throw new IndexOutOfBoundsException(下标越界); } Contact removed data[index]; for (int i index; i size - 1; i) { data[i] data[i 1]; } data[--size] null; // 释放引用避免内存泄漏 return removed; } }删除操作的搬移方向必须是从前往后——第 28 行data[i] data[i1]如果写反了从后往前搬后面的元素会把前面的覆盖掉删除就变成错乱。第 29 行把最后一个位置置null这是课设代码里容易被忽略的细节数组里不再使用的对象引用如果不置空大对象集合场景下会拖累垃圾回收。扩容为什么是翻倍不是加固定值翻倍均摊下来的单次插入时间复杂度是 O(1)加固定值会退化成 O(n)这也是面试官爱问的点。3.3 查找顺序查找与二分查找的结合通讯录支持按姓名精确查找和按电话精确查找。姓名的查找用顺序遍历因为联系人数据默认是按姓名排序的可以顺手做一个二分查找。但电话无序只能线性扫描。这里其实可以拆成两个方法策略清晰。// 按姓名二分查找基于 compareTo 排序的前提 public int binarySearchByName(String name) { int low 0, high size - 1; while (low high) { int mid (low high) / 2; int cmp data[mid].getName().compareTo(name); if (cmp 0) { return mid; } else if (cmp 0) { low mid 1; } else { high mid - 1; } } return -1; }二分查找的循环条件必须是low high等于号丢了会漏掉边界元素——查的正好是第一个或最后一个元素时就翻车。(low high) / 2在数据量大时可能有整型溢出风险这里数据量小无伤大雅但课设答辩时你能主动说出这个潜在问题会加分不少。需要注意的是如果用户先执行了“添加”操作数据就不保持有序了此时再用二分查找会出错。解决办法是每次添加或修改后自动排序或者查找前检查标志位。这套代码的处理方式是通讯录每次返回主菜单前调用一次排序保持有序状态。3.4 排序默认按姓名电话排序作为扩展排序方法体现了顺序表最典型的搬移操作。课程设计评分通常要求“至少实现一种内部排序算法”这套代码里实现了一个简单的冒泡排序——不是因为冒泡性能好而是因为它最容易讲清楚比较和交换的过程。注意排序的触发点不是每次 add 都排而是展示列表时惰性排序避免频繁排序影响交互响应。public void sortByName() { for (int i 0; i size - 1; i) { boolean swapped false; for (int j 0; j size - 1 - i; j) { if (data[j].compareTo(data[j 1]) 0) { Contact tmp data[j]; data[j] data[j 1]; data[j 1] tmp; swapped true; } } if (!swapped) break; // 本轮无交换已提前有序 } }这里的swapped标志位做的是“提前终止优化”如果一次完整遍历下来没有任何交换说明数组已经有序直接跳出循环。这个细节在答辩时一句带过即可但代码里有没有写识货的老师一眼就能看出来。给电话排序时只需要让Contact增加一个compareByPhone方法排序方法里调用它替换compareTo这就是把比较规则从排序算法中解耦出来的好处。4. 24点扑克牌核心拆解从四张牌到完整算式的生成链路24点模块的算法链路是四张牌的全排列 × 64 种运算符组合 × 5 种括号结构逐一生成中缀表达式再用双栈求值器判断是否等于24。这个过程把递归、组合枚举、栈三个数据结构考点全串起来了是整个课设里技术含量最高的一章。4.1 全排列生成递归交换法四张牌的所有排列有 4! 24 种。生成办法用经典的交换回溯递归固定第 index 位把后面每个元素换过来递归完再换回去。这样做不需要额外的标记数组空间开销最小。public class Permutation { public static void generate(int[] nums, int index, Listint[] result) { if (index nums.length - 1) { result.add(nums.clone()); // 到最后一个位置记录一份排列 return; } for (int i index; i nums.length; i) { swap(nums, index, i); generate(nums, index 1, result); swap(nums, index, i); // 回溯换回来 } } private static void swap(int[] arr, int i, int j) { int tmp arr[i]; arr[i] arr[j]; arr[j] tmp; } }注意第 6 行nums.clone()必须克隆一份不能直接result.add(nums)因为后续递归还会修改 nums 数组存引用的话最终所有排列都会变成最后一次递归后的状态——这是新手必踩的“引用别名”大坑。展开过程可以用一个例子理解数字[1,2,3]第一次 index 0i0 时不交换递归处理[2,3]i1 时交换成[2,1,3]递归处理[1,3]以此类推。回溯的 swap 保证了每层循环开始时数组是初始顺序。4.2 括号结构5 种模板穷举四张牌、三个运算符能构成的中缀表达式括号形态一共有 5 种。这里直接枚举五种模板而不是动态拼接括号——简单直接不会漏。模板里的字母代表数字位置运算符位置用占位符。public class ExpressionGenerator { // 5 种括号结构模板占位符 {a}{b}{c}{d} 是数字{op1}{op2}{op3} 是运算符 private static final String[] TEMPLATES { (({a}{op1}{b}){op2}({c}{op3}{d})), // (a op b) op (c op d) ((({a}{op1}{b}){op2}{c}){op3}{d}), // ((a op b) op c) op d ({a}{op1}({b}{op2}({c}{op3}{d}))), // a op (b op (c op d)) (({a}{op1}({b}{op2}{c})){op3}{d}), // (a op (b op c)) op d ({a}{op1}(({b}{op2}{c}){op3}{d})) // a op ((b op c) op d) }; public static ListString generateAll(String[] nums, char[] ops) { ListString expressions new ArrayList(); for (String template : TEMPLATES) { String expr template; for (int i 0; i 4; i) { expr expr.replace({a}.replace(a, String.valueOf(i)), nums[i]); } // 依次替换运算符占位符 for (int i 0; i 3; i) { expr expr.replace({op (i 1) }, String.valueOf(ops[i])); } expressions.add(expr); } return expressions; } }五种模板看起来相似但覆盖了所有二元运算的括号组合第一种是“两两先算再合并”第二种是最常见的“从前往后逐步计算”第三、四、五种是各种形状的左结合和右结合。模板写的是{a}{b}{c}{d}这种命名方式是为了在replace时避免{a}和{ab}混淆虽然笨一点但稳定可靠。4.3 运算符组合4 的 3 次方种穷举每个数字之间放一个运算符运算符是加减乘除四种三处共有 4^3 64 种组合。用三层循环即可全部列出和全排列组合在一起总尝试次数 24 × 64 × 5 7680 种。这个数量级对现代机器是毫秒级的所以暴力枚举在这个场景下完全可行不需要做剪枝优化。char[] operators {, -, *, /}; ListString allExprs new ArrayList(); for (char op1 : operators) { for (char op2 : operators) { for (char op3 : operators) { char[] ops {op1, op2, op3}; for (String[] perm : allPerms) { // 全排列结果 ListString exprs ExpressionGenerator.generateAll(perm, ops); allExprs.addAll(exprs); } } } }三层循环嵌套写起来有点丑但这是最直白也最容易讲清楚的写法。如果非要显摆一下可以用递归把任意数量运算符的排列也统一处理但课程设计环节能跑对比什么都重要。这里循环的顺序是“运算符外层、排列内层”这样生成结果按运算符分组方便后面去重和统计。4.4 双栈求值器中缀转后缀再计算生成了中缀表达式接下来要判断它是否等于24。这里用经典的“双栈”实现一个栈放操作数一个栈放运算符。先扫描中缀表达式转成后缀逆波兰再对后缀表达式做一次计算。public class Evaluator { public static double evaluate(String infix) { String[] tokens infix.split((?[\\-*/()])|(?[\\-*/()])); // 步骤一中缀转后缀 DequeCharacter opStack new ArrayDeque(); StringBuilder postfix new StringBuilder(); for (String token : tokens) { char c token.charAt(0); if (Character.isDigit(c)) { postfix.append(token).append( ); } else if (c () { opStack.push(c); } else if (c )) { while (!opStack.isEmpty() opStack.peek() ! () { postfix.append(opStack.pop()).append( ); } opStack.pop(); // 丢弃左括号 } else { // 运算符 while (!opStack.isEmpty() precedence(opStack.peek()) precedence(c)) { postfix.append(opStack.pop()).append( ); } opStack.push(c); } } while (!opStack.isEmpty()) { postfix.append(opStack.pop()).append( ); } // 步骤二计算后缀表达式 DequeDouble numStack new ArrayDeque(); for (String token : postfix.toString().trim().split( )) { if (token.matches(\\d)) { numStack.push(Double.parseDouble(token)); } else { double b numStack.pop(); double a numStack.pop(); numStack.push(apply(token.charAt(0), a, b)); } } return numStack.pop(); } private static int precedence(char op) { return (op || op -) ? 1 : 2; } private static double apply(char op, double a, double b) { return switch (op) { case - a b; case - - a - b; case * - a * b; case / - a / b; default - throw new IllegalArgumentException(非法运算符); }; } }第 2 行用正则拆 token(?[\\-*/()])是向后匹配(?[\\-*/()])是向前匹配这个正则会保证“123”拆成“12”“”“3”而不是拆成“1”“2”。注意字符类里减号要转义成\\-否则会被当成范围连接符。操作数栈计算时第 18 行numStack.pop()两次第一次拿到的是右操作数b第二次才是左操作数a顺序反了减法除法会出大问题——这是双栈求值最阴的坑。4.5 结果输出去重与格式化所有 7680 种表达式里会有一大堆重复解比如 123×4 和 3×412 本质是同一个算式。课程设计会要求“列出所有解”但不说“列出所有重复解”。去重策略是用一个SetString记录表达式去掉所有括号后的标准化形态只保留第一次出现的形态。SetString seen new HashSet(); ListString solutions new ArrayList(); for (String expr : allExprs) { double result Evaluator.evaluate(expr); if (Math.abs(result - 24) 1e-6) { // 浮点数比较用精度 String key expr.replaceAll([()], ); // 去掉括号作去重键 if (seen.add(key)) { solutions.add(expr); } } }去重键用的是“去括号后的中缀串”这样(12)(3×4)和(3×4)(12)都会归一化成123×4只能保留一个。这个去重方案不算完美但课设场景下足够。浮点比较用Math.abs(result - 24) 1e-6而不是result 24因为浮点数运算有精度误差8/(3-8/3)这种算式算出来可能是 24.000000000000004。5. 避坑记录跑通24点模块路上的五个大坑写这个模块的过程基本就是一部踩坑史。有些坑是数据结构的经典问题有些是 Java 语言本身的陷阱。整理五条最有代表性的每条都是“现象 → 原因 → 解决”的结构希望能帮后来者少走弯路。5.1 除零导致程序直接崩溃现象程序运行到某个组合时抛出ArithmeticException: / by zero整个模块退出。原因枚举运算符组合时/后面的操作数可能恰好是 0比如5 ÷ 0。解决在apply方法里对除法分支加判断b 0时返回一个特殊标记值而不是抛异常。实际代码里更稳妥的做法是在生成表达式时就不允许除数为 0——但那样会漏掉(8-8)这种“括号内先算出 0 再作为除数”的情况所以必须在求值阶段统一处理返回NaN并在外层判定时直接排除。5.2 四张牌有重复时的全排列冗余现象输入 [4, 4, 4, 4] 时输出结果列表里同一算式出现好几百遍。原因全排列算法把四个 4 当作不同的元素处理4 个相同数字有 24 种排列但实际产生的中缀表达式大部分雷同。解决在生成全排列前先对数组排序递归时跳过与前一个位置相同的元素——这是经典的全排列去重写法if (i index nums[i] nums[i-1]) continue;。5.3 减法除法顺序反转导致结果错误现象明明能算出 24 的四张牌程序一个解都找不到。原因evaluate阶段操作数栈弹出顺序是右操作数优先但手写的apply里如果写反了 a 和 b减法变成了“右减左”除法变成了“右除左”。解决统一约定apply(char op, double a, double b)中 a 是左操作数、b 是右操作数后缀计算循环里弹栈时第一个 pop 出来的是 b第二个是 a。这个顺序问题不止影响 24 点任何中缀转后缀的求值器都会遇到。5.4 浮点判断“恰好等于24”把正确结果排除现象人工验证某个组合确实能算出 24但程序不输出。原因浮点运算不是精确的8/(3-8/3)在 double 下结果是 23.999999999999996直接 24比较返回 false。解决所有结果判断一律用Math.abs(result - 24) 1e-6这个误差阈值选 1e-6 是因为表达式中间结果都是有理数运算double 累加误差一般不会超过这个量级。不要用 1e-9 这种过严的阈值有些极端除法表达式误差会更大。5.5 括号模板替换顺序导致变量名污染现象生成表达式时字符串里残留未替换的{a}占位符。原因用replace依次替换{a}、{b}、{c}、{d}时如果数字恰好是两位数replace({a}, multiDigit)会把后续占位符的子串也波及。解决占位符加上数字下标如{num0}、{num1}替换时按序号严格匹配或者直接用StringBuilder拼接表达式哪里需要数字就拼哪里。这个坑在模板数量少时不容易暴露一旦把模板扩展成嵌套括号较深的结构就会踩到。6. 二次开发实战把顺序表换成链表、给24点加计时跑通只是第一步拿到高分还得靠改。这章给几个明确可落地的改造方向按难度从小到大排列每个都说明改哪里、怎么验证可以直接照抄进自己的课程设计报告里作为“创新点”。6.1 通讯录模块把存储结构从顺序表换成链表ContactList的接口定义不变新增一个ContactLinkedList类实现同样的增删改查方法内部用双向链表节点串联。重点改造的是删除和插入原来顺序表删除要搬移数组元素链表删除只需要改前后节点的指针。验证方式跑同一组测试用例——新增 100 个联系人、删除第 50 个、按姓名查找记录操作耗时。顺序表查第 50 个是data[49]直接定位链表要从头遍历所以链表更适合频繁插入删除、随机访问少的场景对照实验的结论写进报告很加分。6.2 24点模块加入单组计时和多组计分改造Poker24Game.run()每一轮发牌后用System.nanoTime()记录用户解题消耗时间超过 60 秒自动跳过并统计为失败。用HashMapString, Integer维护累计得分和解题数封装一个简单的计分规则解出加 10 分超时扣 5 分连续答对三题额外加 5 分连击奖励。验证方式手动跑五轮确认计分累加逻辑无边界溢出再把自动求解的表达式打印出来人工核对每轮结果。6.3 把输入校验统一换成 Java 的正则框架现在InputUtil只是简单转 int 和取字符串可以扩展一个readPhone()专门校验手机号格式用正则^1[3-9]\\d{9}$来判断合法性输入不合法就循环重输。这样通讯录模块录入电话号码时非法号码根本进不到数据层提前拦截比入库后再校验要省事得多。验证方式输入13812345678能通过输入12345被拒绝并提示重新输入。6.4 验证方法把“能跑”升级成“可测试”课程设计答辩最怕评委现场改输入搞出异常。改成 JUnit 测试类是最稳妥的验证手段给Evaluator写一个测试方法直接调用Evaluator.evaluate((123)*4)断言返回值等于 24给ContactList写一个添加删除的测试断言 size 变化正确。你不用引额外的测试框架Java 自带 JUnit 4 的依赖在大多数开发工具里都能找到把测试代码的截图放进课程设计报告说服力比“我手动试过没问题”强一个量级。做完这些改造你交上去的课设已经具备了“能演示、能讲解、能扛住问询”的三要素。我从头到尾拆一遍这项目的最大感受是数据结构课设的代码不是关键关键是你能否讲清楚“为什么这个场景选顺序表、为什么这个算式中缀转后缀要用栈”。把那五个坑和思路走通答辩基本就稳了。希望帮到你。本文还有配套的精品资源点击获取
简介数据结构课程设计资源包内含两个经典Java项目手机通讯录模拟与24点扑克牌游戏覆盖链表、数组、哈希表、排序等数据结构核心应用适合高校学生完成课程设计、备战考试或巩固Java编程能力。压缩包共73个文件整体仅431KB以53张PNG运行截图为主体直观展示界面与执行结果另有5个Java源码、8个XML配置、5个class编译文件并附带IDEA工程文件与说明HTML便于导入工程对照研读。目前已有652人学习下载实用性获得认可。项目完整实现通讯录的增删查改与按姓名快速查找详细演示ArrayList、LinkedList及HashMap的典型用法24点游戏采用深度优先搜索与回溯算法穷举全部加减乘除组合帮助深入理解递归与栈机制同时涉及Set避免重复计算、优先队列优化搜索等进阶技巧。资源虽小但组织结构清晰运行截图丰富代码注释到位适合需要快速上手课程设计或系统复习数据结构知识点的读者。1. 这个课程设计项目把两座“大山”一次翻过去了数据结构课程设计最怕的题目有两个一个是通讯录模拟听着简单真写起来增删改查排序查找全都要从头实现另一个是24点扑克牌游戏算法思路谁都懂真让代码把所有解都列出来并输出算式能耗掉一礼拜。这套资源恰好把 java 数据结构 课程设计里的这两大经典题目打包在了一起用纯 Java 控制台程序实现不依赖任何框架。项目一共两个独立模块手机通讯录模拟——用自实现的顺序表完成联系人的增删改查、排序、二分查找和分组统计24点扑克牌游戏——用递归全排列加双栈表达式求值穷举所有能算出24的算式并输出。它适合两类人正在准备数据结构课设、需要参考完整源码的学生以及想把线性表、栈、递归这些抽象概念落到真实代码里的开发者。看完这篇你能照着我拆出来的代码结构把项目跑起来并改成自己的课设版本。2. 整体架构与设计两个模块如何共享一套底层代码拿到题目第一反应是“这不就两个小 Demo 吗”真动手才发现课设提交要的是完整工程菜单、输入校验、异常处理、模块划分、注释规范一样都不能少。这套资源没有用 Spring 那套重型框架而是回归原生 Java 控制台程序——数据结构课设的核心考察点是数据结构和算法的实现不是框架用法这一点设计得很务实。2.1 包结构与类职责划分整个工程按功能拆成四个包干净利落。主程序只负责菜单分发业务逻辑全部分离到具体类里这符合课程设计的评分标准里“模块化设计”这一项。src/ ├── com/course/design/ │ ├── Main.java // 主入口菜单循环 │ ├── common/ │ │ ├── InputUtil.java // 统一输入工具防数字格式异常 │ │ └── Menu.java // 菜单渲染与路由 │ ├── contacts/ │ │ ├── Contact.java // 联系人实体实现 Comparable │ │ └── ContactList.java // 顺序表实现增删改查排序查找 │ └── poker/ │ ├── Card.java // 扑克牌抽象点数、花色 │ ├── Permutation.java // 四个数字的全排列生成 │ ├── ExpressionGenerator.java // 括号模板与运算符组合 │ ├── Evaluator.java // 双栈表达式求值器 │ └── Poker24Game.java // 24点主业务逻辑这种划分的逻辑是通讯录模块考察线性表24点模块考察递归和栈。contacts包里的ContactList是自实现的顺序表没有用ArrayList偷懒——这是课程设计评分时重点检查的地方poker包里把“生成算式”和“计算算式”分成两个类前者负责纯枚举后者负责用栈求值职责互不干扰调试的时候定位问题特别方便。2.2 技术选型为什么用顺序表而不是链表或数据库通讯录模块的数据存储是在顺序表和链表之间纠结过的。顺序表的优势是随机访问快、实现简单缺点是插入删除要搬移元素链表正好相反。联系人这个场景绝大多数操作是“按姓名查找”和“展示全部”插入删除频率不高所以顺序表更合适。这样还顺便覆盖了“顺序表实现”这个课程设计考点。24点模块的存储更轻量四个数字就是int[]数组递归生成全排列时直接在数组上交换元素连额外的集合都不用。求值阶段需要后进先出的特性这里用栈——中缀表达式先转成后缀表达式再用栈计算结果一次性把“栈的应用”这个考点评分点也拿到了。2.3 输入工具与异常防御控制台程序最烦的坑是用户输入了非数字导致程序崩溃。课程设计答辩现场评委一定会拿异常输入来试你的程序。这套代码做了一个统一的InputUtil核心思路是“出错重来而不是崩溃退出”。量级不大但对课设程序的鲁棒性提升非常明显。public class InputUtil { private static final Scanner scanner new Scanner(System.in); // 读取一个 int出错自动重输入 public static int readInt(String prompt) { while (true) { System.out.print(prompt); String line scanner.nextLine().trim(); try { return Integer.parseInt(line); } catch (NumberFormatException e) { System.out.println(输入无效请重新输入整数); } } } // 读取一个字符串去掉首尾空格 public static String readLine(String prompt) { System.out.print(prompt); return scanner.nextLine().trim(); } }这个工具类被两个模块复用。readInt里用while(true)循环包住解析逻辑解析失败就提示并回到起点输入“abc”不会崩溃只会反复提醒。parseInt在 Java 里对“12abc”这种混合字符串会直接抛异常所以 catch 住就完事了。注意第 6 行 scanner 对象是静态的程序启动时创建一次避免多个实例在控制台输入时产生缓冲区错乱的问题。2.4 主菜单路由与控制流Main 类的菜单路由用了一个 switch 分发这是控制台程序最直观的做法。不做面向对象的策略模式因为课程设计阶段可读性比扩展性重要。菜单循环的退出条件是用户输入 0每次操作完成后回到主菜单不会直接退出程序——这是课设程序的“基本素养”提交的代码要能连续操作多轮。public class Main { public static void main(String[] args) { boolean running true; while (running) { int choice Menu.showMainMenu(); switch (choice) { case 1 - new ContactApp().run(); // 通讯录模块 case 2 - new Poker24Game().run(); // 24点模块 case 0 - { System.out.println(程序退出感谢使用); running false; } default - System.out.println(无效选项请重新选择); } } } }这里case 1和case 2的写法是 Java 14 之后的箭头语法如果学校的编译环境是 Java 8要改成传统的case 1: ... break;形式。每个模块的run()方法内部自己维护二级菜单循环主菜单只负责“进哪个模块”不做业务处理。这样的层级关系答辩时画一个程序流程图就能说清楚整体控制流。3. 通讯录模块核心拆解一个联系人的完整生命周期通讯录模块的考察点集中在ContactList这个顺序表实现上。这里有一个课设评分认可的常见做法联系人实体Contact实现Comparable接口把“按什么排序”的逻辑内聚到实体自己身上排序方法只负责比较器的调用这样后面扩展按电话排序时改一行代码就能搞定。3.1 联系人实体与比较规则Contact是一个典型的 POJO字段包括姓名、电话、分组、备注外加一个compareTo方法。排序默认按姓名走字典序这样Collections.sort或者手写排序直接用实体自身的比较规则即可。public class Contact implements ComparableContact { private String name; // 姓名 private String phone; // 电话号码 private String group; // 分组家人/朋友/同事 private String remark; // 备注 Override public int compareTo(Contact o) { // 姓名相同再比较电话号码保证排序稳定性 int cmp this.name.compareTo(o.name); if (cmp ! 0) return cmp; return this.phone.compareTo(o.phone); } }compareTo里先比姓名再比电话这个“二级排序键”的设计避免了一个实际问题通讯录里存在同名联系人时只按姓名排序会导致顺序不稳定。注意第 6 行compareTo返回的是字典序差值不是简单返回 0 或 1因为sort依赖这个返回值的正负号来判断谁前谁后。3.2 顺序表扩容、插入与删除ContactList底层用一个Contact[]数组存数据size记录当前有效元素个数。扩容的时机是在插入前判断数组满了就翻倍扩容。这一套逻辑手写的时候最容易漏“数组越界”的边界情况。public class ContactList { private Contact[] data; // 底层数组 private int size; // 当前元素个数 private static final int DEFAULT_CAPACITY 10; public ContactList() { data new Contact[DEFAULT_CAPACITY]; size 0; } // 扩容数组长度翻倍旧数据搬移 private void ensureCapacity() { if (size data.length) { Contact[] newData new Contact[data.length * 2]; System.arraycopy(data, 0, newData, 0, size); data newData; } } // 尾部添加 public void add(Contact c) { ensureCapacity(); data[size] c; } // 按下标删除后面元素依次前移 public Contact remove(int index) { if (index 0 || index size) { throw new IndexOutOfBoundsException(下标越界); } Contact removed data[index]; for (int i index; i size - 1; i) { data[i] data[i 1]; } data[--size] null; // 释放引用避免内存泄漏 return removed; } }删除操作的搬移方向必须是从前往后——第 28 行data[i] data[i1]如果写反了从后往前搬后面的元素会把前面的覆盖掉删除就变成错乱。第 29 行把最后一个位置置null这是课设代码里容易被忽略的细节数组里不再使用的对象引用如果不置空大对象集合场景下会拖累垃圾回收。扩容为什么是翻倍不是加固定值翻倍均摊下来的单次插入时间复杂度是 O(1)加固定值会退化成 O(n)这也是面试官爱问的点。3.3 查找顺序查找与二分查找的结合通讯录支持按姓名精确查找和按电话精确查找。姓名的查找用顺序遍历因为联系人数据默认是按姓名排序的可以顺手做一个二分查找。但电话无序只能线性扫描。这里其实可以拆成两个方法策略清晰。// 按姓名二分查找基于 compareTo 排序的前提 public int binarySearchByName(String name) { int low 0, high size - 1; while (low high) { int mid (low high) / 2; int cmp data[mid].getName().compareTo(name); if (cmp 0) { return mid; } else if (cmp 0) { low mid 1; } else { high mid - 1; } } return -1; }二分查找的循环条件必须是low high等于号丢了会漏掉边界元素——查的正好是第一个或最后一个元素时就翻车。(low high) / 2在数据量大时可能有整型溢出风险这里数据量小无伤大雅但课设答辩时你能主动说出这个潜在问题会加分不少。需要注意的是如果用户先执行了“添加”操作数据就不保持有序了此时再用二分查找会出错。解决办法是每次添加或修改后自动排序或者查找前检查标志位。这套代码的处理方式是通讯录每次返回主菜单前调用一次排序保持有序状态。3.4 排序默认按姓名电话排序作为扩展排序方法体现了顺序表最典型的搬移操作。课程设计评分通常要求“至少实现一种内部排序算法”这套代码里实现了一个简单的冒泡排序——不是因为冒泡性能好而是因为它最容易讲清楚比较和交换的过程。注意排序的触发点不是每次 add 都排而是展示列表时惰性排序避免频繁排序影响交互响应。public void sortByName() { for (int i 0; i size - 1; i) { boolean swapped false; for (int j 0; j size - 1 - i; j) { if (data[j].compareTo(data[j 1]) 0) { Contact tmp data[j]; data[j] data[j 1]; data[j 1] tmp; swapped true; } } if (!swapped) break; // 本轮无交换已提前有序 } }这里的swapped标志位做的是“提前终止优化”如果一次完整遍历下来没有任何交换说明数组已经有序直接跳出循环。这个细节在答辩时一句带过即可但代码里有没有写识货的老师一眼就能看出来。给电话排序时只需要让Contact增加一个compareByPhone方法排序方法里调用它替换compareTo这就是把比较规则从排序算法中解耦出来的好处。4. 24点扑克牌核心拆解从四张牌到完整算式的生成链路24点模块的算法链路是四张牌的全排列 × 64 种运算符组合 × 5 种括号结构逐一生成中缀表达式再用双栈求值器判断是否等于24。这个过程把递归、组合枚举、栈三个数据结构考点全串起来了是整个课设里技术含量最高的一章。4.1 全排列生成递归交换法四张牌的所有排列有 4! 24 种。生成办法用经典的交换回溯递归固定第 index 位把后面每个元素换过来递归完再换回去。这样做不需要额外的标记数组空间开销最小。public class Permutation { public static void generate(int[] nums, int index, Listint[] result) { if (index nums.length - 1) { result.add(nums.clone()); // 到最后一个位置记录一份排列 return; } for (int i index; i nums.length; i) { swap(nums, index, i); generate(nums, index 1, result); swap(nums, index, i); // 回溯换回来 } } private static void swap(int[] arr, int i, int j) { int tmp arr[i]; arr[i] arr[j]; arr[j] tmp; } }注意第 6 行nums.clone()必须克隆一份不能直接result.add(nums)因为后续递归还会修改 nums 数组存引用的话最终所有排列都会变成最后一次递归后的状态——这是新手必踩的“引用别名”大坑。展开过程可以用一个例子理解数字[1,2,3]第一次 index 0i0 时不交换递归处理[2,3]i1 时交换成[2,1,3]递归处理[1,3]以此类推。回溯的 swap 保证了每层循环开始时数组是初始顺序。4.2 括号结构5 种模板穷举四张牌、三个运算符能构成的中缀表达式括号形态一共有 5 种。这里直接枚举五种模板而不是动态拼接括号——简单直接不会漏。模板里的字母代表数字位置运算符位置用占位符。public class ExpressionGenerator { // 5 种括号结构模板占位符 {a}{b}{c}{d} 是数字{op1}{op2}{op3} 是运算符 private static final String[] TEMPLATES { (({a}{op1}{b}){op2}({c}{op3}{d})), // (a op b) op (c op d) ((({a}{op1}{b}){op2}{c}){op3}{d}), // ((a op b) op c) op d ({a}{op1}({b}{op2}({c}{op3}{d}))), // a op (b op (c op d)) (({a}{op1}({b}{op2}{c})){op3}{d}), // (a op (b op c)) op d ({a}{op1}(({b}{op2}{c}){op3}{d})) // a op ((b op c) op d) }; public static ListString generateAll(String[] nums, char[] ops) { ListString expressions new ArrayList(); for (String template : TEMPLATES) { String expr template; for (int i 0; i 4; i) { expr expr.replace({a}.replace(a, String.valueOf(i)), nums[i]); } // 依次替换运算符占位符 for (int i 0; i 3; i) { expr expr.replace({op (i 1) }, String.valueOf(ops[i])); } expressions.add(expr); } return expressions; } }五种模板看起来相似但覆盖了所有二元运算的括号组合第一种是“两两先算再合并”第二种是最常见的“从前往后逐步计算”第三、四、五种是各种形状的左结合和右结合。模板写的是{a}{b}{c}{d}这种命名方式是为了在replace时避免{a}和{ab}混淆虽然笨一点但稳定可靠。4.3 运算符组合4 的 3 次方种穷举每个数字之间放一个运算符运算符是加减乘除四种三处共有 4^3 64 种组合。用三层循环即可全部列出和全排列组合在一起总尝试次数 24 × 64 × 5 7680 种。这个数量级对现代机器是毫秒级的所以暴力枚举在这个场景下完全可行不需要做剪枝优化。char[] operators {, -, *, /}; ListString allExprs new ArrayList(); for (char op1 : operators) { for (char op2 : operators) { for (char op3 : operators) { char[] ops {op1, op2, op3}; for (String[] perm : allPerms) { // 全排列结果 ListString exprs ExpressionGenerator.generateAll(perm, ops); allExprs.addAll(exprs); } } } }三层循环嵌套写起来有点丑但这是最直白也最容易讲清楚的写法。如果非要显摆一下可以用递归把任意数量运算符的排列也统一处理但课程设计环节能跑对比什么都重要。这里循环的顺序是“运算符外层、排列内层”这样生成结果按运算符分组方便后面去重和统计。4.4 双栈求值器中缀转后缀再计算生成了中缀表达式接下来要判断它是否等于24。这里用经典的“双栈”实现一个栈放操作数一个栈放运算符。先扫描中缀表达式转成后缀逆波兰再对后缀表达式做一次计算。public class Evaluator { public static double evaluate(String infix) { String[] tokens infix.split((?[\\-*/()])|(?[\\-*/()])); // 步骤一中缀转后缀 DequeCharacter opStack new ArrayDeque(); StringBuilder postfix new StringBuilder(); for (String token : tokens) { char c token.charAt(0); if (Character.isDigit(c)) { postfix.append(token).append( ); } else if (c () { opStack.push(c); } else if (c )) { while (!opStack.isEmpty() opStack.peek() ! () { postfix.append(opStack.pop()).append( ); } opStack.pop(); // 丢弃左括号 } else { // 运算符 while (!opStack.isEmpty() precedence(opStack.peek()) precedence(c)) { postfix.append(opStack.pop()).append( ); } opStack.push(c); } } while (!opStack.isEmpty()) { postfix.append(opStack.pop()).append( ); } // 步骤二计算后缀表达式 DequeDouble numStack new ArrayDeque(); for (String token : postfix.toString().trim().split( )) { if (token.matches(\\d)) { numStack.push(Double.parseDouble(token)); } else { double b numStack.pop(); double a numStack.pop(); numStack.push(apply(token.charAt(0), a, b)); } } return numStack.pop(); } private static int precedence(char op) { return (op || op -) ? 1 : 2; } private static double apply(char op, double a, double b) { return switch (op) { case - a b; case - - a - b; case * - a * b; case / - a / b; default - throw new IllegalArgumentException(非法运算符); }; } }第 2 行用正则拆 token(?[\\-*/()])是向后匹配(?[\\-*/()])是向前匹配这个正则会保证“123”拆成“12”“”“3”而不是拆成“1”“2”。注意字符类里减号要转义成\\-否则会被当成范围连接符。操作数栈计算时第 18 行numStack.pop()两次第一次拿到的是右操作数b第二次才是左操作数a顺序反了减法除法会出大问题——这是双栈求值最阴的坑。4.5 结果输出去重与格式化所有 7680 种表达式里会有一大堆重复解比如 123×4 和 3×412 本质是同一个算式。课程设计会要求“列出所有解”但不说“列出所有重复解”。去重策略是用一个SetString记录表达式去掉所有括号后的标准化形态只保留第一次出现的形态。SetString seen new HashSet(); ListString solutions new ArrayList(); for (String expr : allExprs) { double result Evaluator.evaluate(expr); if (Math.abs(result - 24) 1e-6) { // 浮点数比较用精度 String key expr.replaceAll([()], ); // 去掉括号作去重键 if (seen.add(key)) { solutions.add(expr); } } }去重键用的是“去括号后的中缀串”这样(12)(3×4)和(3×4)(12)都会归一化成123×4只能保留一个。这个去重方案不算完美但课设场景下足够。浮点比较用Math.abs(result - 24) 1e-6而不是result 24因为浮点数运算有精度误差8/(3-8/3)这种算式算出来可能是 24.000000000000004。5. 避坑记录跑通24点模块路上的五个大坑写这个模块的过程基本就是一部踩坑史。有些坑是数据结构的经典问题有些是 Java 语言本身的陷阱。整理五条最有代表性的每条都是“现象 → 原因 → 解决”的结构希望能帮后来者少走弯路。5.1 除零导致程序直接崩溃现象程序运行到某个组合时抛出ArithmeticException: / by zero整个模块退出。原因枚举运算符组合时/后面的操作数可能恰好是 0比如5 ÷ 0。解决在apply方法里对除法分支加判断b 0时返回一个特殊标记值而不是抛异常。实际代码里更稳妥的做法是在生成表达式时就不允许除数为 0——但那样会漏掉(8-8)这种“括号内先算出 0 再作为除数”的情况所以必须在求值阶段统一处理返回NaN并在外层判定时直接排除。5.2 四张牌有重复时的全排列冗余现象输入 [4, 4, 4, 4] 时输出结果列表里同一算式出现好几百遍。原因全排列算法把四个 4 当作不同的元素处理4 个相同数字有 24 种排列但实际产生的中缀表达式大部分雷同。解决在生成全排列前先对数组排序递归时跳过与前一个位置相同的元素——这是经典的全排列去重写法if (i index nums[i] nums[i-1]) continue;。5.3 减法除法顺序反转导致结果错误现象明明能算出 24 的四张牌程序一个解都找不到。原因evaluate阶段操作数栈弹出顺序是右操作数优先但手写的apply里如果写反了 a 和 b减法变成了“右减左”除法变成了“右除左”。解决统一约定apply(char op, double a, double b)中 a 是左操作数、b 是右操作数后缀计算循环里弹栈时第一个 pop 出来的是 b第二个是 a。这个顺序问题不止影响 24 点任何中缀转后缀的求值器都会遇到。5.4 浮点判断“恰好等于24”把正确结果排除现象人工验证某个组合确实能算出 24但程序不输出。原因浮点运算不是精确的8/(3-8/3)在 double 下结果是 23.999999999999996直接 24比较返回 false。解决所有结果判断一律用Math.abs(result - 24) 1e-6这个误差阈值选 1e-6 是因为表达式中间结果都是有理数运算double 累加误差一般不会超过这个量级。不要用 1e-9 这种过严的阈值有些极端除法表达式误差会更大。5.5 括号模板替换顺序导致变量名污染现象生成表达式时字符串里残留未替换的{a}占位符。原因用replace依次替换{a}、{b}、{c}、{d}时如果数字恰好是两位数replace({a}, multiDigit)会把后续占位符的子串也波及。解决占位符加上数字下标如{num0}、{num1}替换时按序号严格匹配或者直接用StringBuilder拼接表达式哪里需要数字就拼哪里。这个坑在模板数量少时不容易暴露一旦把模板扩展成嵌套括号较深的结构就会踩到。6. 二次开发实战把顺序表换成链表、给24点加计时跑通只是第一步拿到高分还得靠改。这章给几个明确可落地的改造方向按难度从小到大排列每个都说明改哪里、怎么验证可以直接照抄进自己的课程设计报告里作为“创新点”。6.1 通讯录模块把存储结构从顺序表换成链表ContactList的接口定义不变新增一个ContactLinkedList类实现同样的增删改查方法内部用双向链表节点串联。重点改造的是删除和插入原来顺序表删除要搬移数组元素链表删除只需要改前后节点的指针。验证方式跑同一组测试用例——新增 100 个联系人、删除第 50 个、按姓名查找记录操作耗时。顺序表查第 50 个是data[49]直接定位链表要从头遍历所以链表更适合频繁插入删除、随机访问少的场景对照实验的结论写进报告很加分。6.2 24点模块加入单组计时和多组计分改造Poker24Game.run()每一轮发牌后用System.nanoTime()记录用户解题消耗时间超过 60 秒自动跳过并统计为失败。用HashMapString, Integer维护累计得分和解题数封装一个简单的计分规则解出加 10 分超时扣 5 分连续答对三题额外加 5 分连击奖励。验证方式手动跑五轮确认计分累加逻辑无边界溢出再把自动求解的表达式打印出来人工核对每轮结果。6.3 把输入校验统一换成 Java 的正则框架现在InputUtil只是简单转 int 和取字符串可以扩展一个readPhone()专门校验手机号格式用正则^1[3-9]\\d{9}$来判断合法性输入不合法就循环重输。这样通讯录模块录入电话号码时非法号码根本进不到数据层提前拦截比入库后再校验要省事得多。验证方式输入13812345678能通过输入12345被拒绝并提示重新输入。6.4 验证方法把“能跑”升级成“可测试”课程设计答辩最怕评委现场改输入搞出异常。改成 JUnit 测试类是最稳妥的验证手段给Evaluator写一个测试方法直接调用Evaluator.evaluate((123)*4)断言返回值等于 24给ContactList写一个添加删除的测试断言 size 变化正确。你不用引额外的测试框架Java 自带 JUnit 4 的依赖在大多数开发工具里都能找到把测试代码的截图放进课程设计报告说服力比“我手动试过没问题”强一个量级。做完这些改造你交上去的课设已经具备了“能演示、能讲解、能扛住问询”的三要素。我从头到尾拆一遍这项目的最大感受是数据结构课设的代码不是关键关键是你能否讲清楚“为什么这个场景选顺序表、为什么这个算式中缀转后缀要用栈”。把那五个坑和思路走通答辩基本就稳了。希望帮到你。本文还有配套的精品资源点击获取
平方复杂度无法被常规优化消除｜TaoToken 统一 Key 通道实测)
