用Java手撕数据结构：从ArrayBag到Balanced Search Tree，一个项目搞定CPT102核心考点

在计算机科学的学习过程中，数据结构是构建高效算法的基石。对于正在学习CPT102课程的学生而言，如何将零散的数据结构知识点串联成完整的知识体系，往往是一个挑战。本文将通过一个完整的Java项目——"学生成绩分析系统"，带你从最基础的ArrayBag开始，逐步实现并应用课程中提到的各种抽象数据类型（ADT），最终构建出高效的平衡搜索树结构。

这个项目不仅涵盖了CPT102的核心考点，更重要的是通过实际编码将理论转化为实践能力。我们将从数据收集开始，逐步引入去重、排序、快速检索等功能，在这个过程中你会清晰地看到不同数据结构的选择如何影响系统性能。让我们从项目规划开始，一步步构建这个系统。

1. 项目架构与基础数据结构实现

任何优秀的系统都始于清晰的架构设计。我们的学生成绩分析系统需要处理三类核心数据：学生基本信息、课程信息和成绩记录。为了保持代码的模块化和可扩展性，我们将系统划分为以下几个组件：

• 数据收集模块：使用ArrayBag暂存原始输入数据
• 数据处理模块：包含去重、排序、统计等功能
• 数据存储模块：实现高效查询的数据结构
• 用户接口模块：提供命令行交互界面

首先实现最基础的ArrayBag结构。ArrayBag之所以适合作为起点，是因为它简单直观，能帮助我们快速收集数据而不必考虑顺序和重复问题：

java复制public class ArrayBag<E> implements Iterable<E> {
    private static final int DEFAULT_CAPACITY = 10;
    private E[] elements;
    private int size;
    
    public ArrayBag() {
        elements = (E[]) new Object[DEFAULT_CAPACITY];
        size = 0;
    }
    
    public boolean add(E item) {
        if (size == elements.length) {
            resize(2 * elements.length);
        }
        elements[size++] = item;
        return true;
    }
    
    private void resize(int capacity) {
        E[] newElements = (E[]) new Object[capacity];
        System.arraycopy(elements, 0, newElements, 0, size);
        elements = newElements;
    }
    
    // 其他必要方法...
}

这个基础实现已经能够满足数据收集阶段的需求。注意我们实现了Iterable接口，这是为了后续能够统一使用增强for循环遍历集合。随着项目进展，我们会不断扩展这个基础结构。

提示：在实现任何数据结构时，都应该先明确其核心特性和使用场景。ArrayBag的核心价值在于快速添加和随机访问，而不关心元素顺序和唯一性。

2. 从无序到有序：Set与SortedArraySet的实现与应用

当基础数据收集完成后，我们需要对数据进行清洗和整理。这时Set数据结构就派上用场了。与Bag不同，Set保证了元素的唯一性，这对于学生信息和课程信息这类需要去重的场景非常有用。

我们先实现基本的ArraySet：

java复制public class ArraySet<E> extends ArrayBag<E> {
    @Override
    public boolean add(E item) {
        if (contains(item)) {
            return false;
        }
        return super.add(item);
    }
    
    public boolean contains(E item) {
        for (int i = 0; i < size(); i++) {
            if (get(i).equals(item)) {
                return true;
            }
        }
        return false;
    }
}

这个简单的实现已经能满足去重需求，但查找效率是O(n)。对于需要频繁查询的场景，我们可以进一步优化为SortedArraySet：

java复制public class SortedArraySet<E extends Comparable<E>> extends ArraySet<E> {
    @Override
    public boolean add(E item) {
        if (contains(item)) {
            return false;
        }
        int insertIndex = findInsertIndex(item);
        shiftElementsRight(insertIndex);
        elements[insertIndex] = item;
        size++;
        return true;
    }
    
    private int findInsertIndex(E item) {
        int low = 0, high = size() - 1;
        while (low <= high) {
            int mid = (low + high) / 2;
            int cmp = item.compareTo(get(mid));
            if (cmp == 0) {
                return mid;
            } else if (cmp < 0) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return low;
    }
}

通过维护有序结构，我们可以使用二分查找将contains操作的复杂度降低到O(log n)。下表对比了三种集合结构的特性：

在我们的成绩分析系统中，可以使用ArraySet存储学生名单（避免重复学号），用SortedArraySet存储课程列表（便于快速查找课程信息）。

3. 表达式处理与算法实现：Stack的应用

系统中的一个关键功能是计算学生成绩的综合表达式，例如"(平时成绩0.3 + 期中成绩0.2 + 期末成绩*0.5)"。这类表达式的处理正是Stack数据结构的经典应用场景。

首先实现Stack的基本结构：

java复制public class LinkedStack<E> implements Stack<E> {
    private static class Node<E> {
        E data;
        Node<E> next;
        
        Node(E data) {
            this(data, null);
        }
        
        Node(E data, Node<E> next) {
            this.data = data;
            this.next = next;
        }
    }
    
    private Node<E> top;
    private int size;
    
    public void push(E item) {
        top = new Node<>(item, top);
        size++;
    }
    
    public E pop() {
        if (isEmpty()) {
            throw new NoSuchElementException();
        }
        E result = top.data;
        top = top.next;
        size--;
        return result;
    }
    
    // 其他Stack方法...
}

有了这个基础，我们可以实现中缀表达式到后缀表达式的转换算法：

java复制public static String infixToPostfix(String infix) {
    StringBuilder postfix = new StringBuilder();
    Deque<Character> stack = new ArrayDeque<>();
    
    for (char c : infix.toCharArray()) {
        if (Character.isDigit(c)) {
            postfix.append(c);
        } else if (c == '(') {
            stack.push(c);
        } else if (c == ')') {
            while (!stack.isEmpty() && stack.peek() != '(') {
                postfix.append(stack.pop());
            }
            stack.pop(); // 弹出左括号
        } else {
            while (!stack.isEmpty() && precedence(c) <= precedence(stack.peek())) {
                postfix.append(stack.pop());
            }
            stack.push(c);
        }
    }
    
    while (!stack.isEmpty()) {
        postfix.append(stack.pop());
    }
    
    return postfix.toString();
}

这个算法充分利用了Stack的LIFO特性来处理运算符优先级和括号嵌套。在我们的成绩系统中，这样的表达式处理能力可以让教师灵活定义成绩计算规则。

4. 高效检索：从BST到AVL树的演进

当数据量增大时，高效的检索变得至关重要。Binary Search Tree (BST) 提供了O(log n)的平均查找复杂度，但在最坏情况下（如插入有序数据）会退化为O(n)的链表。这正是我们需要实现自平衡二叉搜索树（AVL树）的原因。

首先实现基础的BST结构：

java复制public class BinarySearchTree<E extends Comparable<E>> {
    private static class Node<E> {
        E data;
        Node<E> left;
        Node<E> right;
        
        Node(E data) {
            this.data = data;
        }
    }
    
    private Node<E> root;
    
    public void insert(E data) {
        root = insert(root, data);
    }
    
    private Node<E> insert(Node<E> node, E data) {
        if (node == null) {
            return new Node<>(data);
        }
        
        int cmp = data.compareTo(node.data);
        if (cmp < 0) {
            node.left = insert(node.left, data);
        } else if (cmp > 0) {
            node.right = insert(node.right, data);
        }
        
        return node;
    }
    
    // 其他BST方法...
}

然后我们扩展为AVL树，通过平衡因子和旋转操作保持平衡：

java复制public class AVLTree<E extends Comparable<E>> extends BinarySearchTree<E> {
    private static class AVLNode<E> extends Node<E> {
        int height;
        
        AVLNode(E data) {
            super(data);
            height = 1;
        }
    }
    
    @Override
    protected Node<E> insert(Node<E> node, E data) {
        // 插入逻辑与BST相同，但使用AVLNode
        // 插入后更新高度并检查平衡
        node = super.insert(node, data);
        updateHeight(node);
        return rebalance(node);
    }
    
    private Node<E> rebalance(Node<E> node) {
        int balanceFactor = getBalanceFactor(node);
        
        if (balanceFactor > 1) {
            if (getBalanceFactor(node.left) >= 0) {
                return rotateRight(node); // LL情况
            } else {
                node.left = rotateLeft(node.left); // LR情况
                return rotateRight(node);
            }
        }
        
        if (balanceFactor < -1) {
            if (getBalanceFactor(node.right) <= 0) {
                return rotateLeft(node); // RR情况
            } else {
                node.right = rotateRight(node.right); // RL情况
                return rotateLeft(node);
            }
        }
        
        return node;
    }
    
    private Node<E> rotateRight(Node<E> y) {
        Node<E> x = y.left;
        Node<E> T2 = x.right;
        
        x.right = y;
        y.left = T2;
        
        updateHeight(y);
        updateHeight(x);
        
        return x;
    }
    
    // 其他AVL树专用方法...
}

在我们的成绩系统中，AVL树非常适合存储需要频繁查询的学生记录。当学生数量达到数千甚至更多时，AVL树能保证稳定的查询性能，而不会出现BST可能出现的性能退化问题。

下表对比了几种常见数据结构的检索性能：

5. 系统集成与性能优化

将各个数据结构模块整合成一个完整的系统，需要考虑模块间的数据流动和接口设计。在我们的学生成绩分析系统中，数据流动大致遵循以下路径：

1. 数据输入阶段：使用ArrayBag收集原始成绩记录
2. 数据清洗阶段：使用Set结构去除重复记录
3. 数据处理阶段：使用Stack处理成绩计算公式
4. 数据存储阶段：使用AVL树存储学生和课程信息
5. 查询阶段：利用Map结构快速统计各类成绩分布

一个关键的设计决策是如何在不同模块间传递数据。我们可以使用Java的Collection接口作为标准接口：

java复制public class GradeAnalyzer {
    private ArrayBag<GradeRecord> rawRecords;
    private Set<Student> students;
    private SortedArraySet<Course> courses;
    private AVLTree<Student> studentIndex;
    private Map<Course, List<GradeRecord>> gradeMap;
    
    public void importRecords(Collection<GradeRecord> records) {
        rawRecords.addAll(records);
        processRawRecords();
    }
    
    private void processRawRecords() {
        for (GradeRecord record : rawRecords) {
            students.add(record.getStudent());
            courses.add(record.getCourse());
            studentIndex.insert(record.getStudent());
            
            if (!gradeMap.containsKey(record.getCourse())) {
                gradeMap.put(record.getCourse(), new ArrayList<>());
            }
            gradeMap.get(record.getCourse()).add(record);
        }
    }
    
    // 其他系统方法...
}

性能优化方面，有几个关键点需要注意：

1. 批量操作：对于大量数据的导入，应该提供批量操作方法，减少重复检查的开销
2. 缓存机制：常用查询结果可以缓存，如班级平均成绩等
3. 延迟加载：非核心数据可以按需加载
4. 内存管理：及时清理不再使用的数据，特别是中间处理结果

注意：在实际项目中，数据结构的选择往往需要权衡。比如虽然AVL树查询高效，但更新成本较高。如果系统更新频率远高于查询频率，可能需要考虑其他结构如跳表(Skip List)。

6. 测试与验证：确保系统可靠性

完善的测试是保证系统可靠性的关键。我们应该为每个数据结构实现编写单元测试，并为整个系统编写集成测试。以AVL树的测试为例：

java复制public class AVLTreeTest {
    @Test
    public void testInsertionBalance() {
        AVLTree<Integer> tree = new AVLTree<>();
        tree.insert(10);
        tree.insert(20);
        tree.insert(30); // 应该触发LL旋转
        
        assertEquals(20, tree.getRoot().data);
        assertEquals(10, tree.getRoot().left.data);
        assertEquals(30, tree.getRoot().right.data);
    }
    
    @Test
    public void testDeletionBalance() {
        AVLTree<Integer> tree = new AVLTree<>();
        tree.insert(10);
        tree.insert(20);
        tree.insert(30);
        tree.insert(40);
        tree.delete(10); // 应该触发RR旋转
        
        assertEquals(30, tree.getRoot().data);
        assertEquals(20, tree.getRoot().left.data);
        assertEquals(40, tree.getRoot().right.data);
    }
}

对于整个系统，我们可以设计端到端的测试场景：

java复制public class GradeAnalyzerIntegrationTest {
    @Test
    public void testFullWorkflow() {
        GradeAnalyzer analyzer = new GradeAnalyzer();
        List<GradeRecord> records = generateTestRecords(1000);
        
        analyzer.importRecords(records);
        
        // 验证数据完整性
        assertEquals(1000, analyzer.getRawRecordCount());
        assertEquals(100, analyzer.getUniqueStudentCount());
        assertEquals(5, analyzer.getCourseCount());
        
        // 验证查询性能
        long start = System.nanoTime();
        Student student = analyzer.findStudent("S20230001");
        long duration = System.nanoTime() - start;
        
        assertNotNull(student);
        assertTrue(duration < 1_000_000); // 查询应在1ms内完成
    }
}

测试应该覆盖正常场景、边界条件和异常情况。特别是对于数据结构实现，要重点测试：

• 空集合操作
• 单元素集合操作
• 满容量操作
• 连续添加和删除操作
• 并发访问情况（如果支持）

7. 扩展思考：从课程项目到工程实践

虽然这个学生成绩分析系统已经涵盖了CPT102课程的大部分核心数据结构，但在实际工程应用中还有更多值得考虑的方向：

1. 持久化存储：将内存中的数据保存到数据库或文件系统
2. 并发控制：处理多线程同时访问数据结构的情况
3. 分布式扩展：当数据量超过单机容量时如何分布存储
4. 可视化界面：提供图形化的数据展示和交互
5. 高级分析功能：如成绩预测、异常检测等

每种扩展都会带来新的数据结构选择问题。例如，持久化存储可能需要考虑B树结构，而分布式系统可能需要一致性哈希等算法。

在实现这些扩展时，Java的集合框架提供了很好的参考。下表对比了我们实现的数据结构与Java标准库中的对应实现：

理解这些底层实现差异有助于我们在不同场景下做出更合适的选择。例如，当内存不是主要限制而查询性能至关重要时，基于哈希表的HashSet通常比我们的ArraySet性能更好；但当数据需要频繁范围查询时，基于树的实现又更具优势。

在实际项目开发中，我通常会先使用Java集合框架快速验证想法，当发现性能瓶颈或特殊需求时，再考虑定制数据结构实现。这种循序渐进的方式既能保证开发效率，又能在必要时进行深度优化。