编程基础加强：深入探索常用的数据结构和应用场景

关注微信公众号 “程序员小胖” 每日技术干货，第一时间送达！

引言

掌握基本的数据结构和算法是提升编程技能的关键。它们不仅在解决复杂问题时发挥着重要作用，而且在技术面试中也是不可或缺的部分。今天，我们将介绍几种常用的数据结构和算法，并通过Java代码示例来加深理解。

数组（Array）

数组（Array）是编程中最基本的数据结构之一，它用于存储一系列相同类型的元素。在Java中，数组是一个固定大小的连续内存空间，用于存储特定类型的元素序列。

特点：

1. 固定大小：数组一旦创建，其大小就不能改变。
2. 连续内存：数组元素在内存中是连续存储的，这使得访问数组元素非常快速。
3. 相同类型：数组中的所有元素必须是相同的数据类型。
4. 索引访问：通过索引可以直接访问数组中的任何元素，索引通常从0开始。

优点：

1. 访问速度快，支持随机访问。
2. 实现简单，易于理解。

缺点：

1. 尺寸固定，不灵活。
2. 插入和删除操作效率低，因为需要移动大量元素。

使用场景：

1. 当你知道将要添加的数据的总数时。
2. 当你需要快速访问数据时。

java代码示例

 public static void main(String[] args) {

      //1创建和初始化数组
      // 1.1 创建一个大小为10的整数数组，所有元素初始为0
      int[] numbers = new int[10];

      //1.2 声明并初始化数组
      int[] scores = {90, 85, 78, 92, 88};

      // 2.访问数组中的元素
      int firstScore = scores[0]; // 获取第一个分数
      int lastScore = scores[scores.length - 1]; // 获取最后一个分数

      // 3.遍历数组
      // 3.1使用for循环遍历数组
      for (int i = 0; i < scores.length; i++) {
          System.out.println("Score: " + scores[i]);
      }
      //3.2使用增强for循环遍历数组（Java 5+）
      for (int score : scores) {
          System.out.println("Score: " + score);
      }

      //4.数组操作**
      //4.1数组长度
      int length = scores.length;
      //4.2数组复制
      int[] newScores = new int[scores.length];
      System.arraycopy(scores, 0, newScores, 0, scores.length);

      //5.多维数组
      //5.1创建二维数组
      int[][] matrix = {
              {1, 2, 3},
              {4, 5, 6},
              {7, 8, 9}
      };
      //5.2访问二维数组元素
      int value = matrix[1][2]; // 获取第二行第三列的值，即5
    }
    

数组是一种简单而强大的数据结构，适用于许多编程场景。理解数组的工作原理和如何在Java中操作数组对于任何程序员来说都是非常重要的。

链表（LinkedList）

链表（LinkedList）是一种常见的数据结构，它由一系列节点组成，每个节点包含数据部分和指向下一个节点的引用（在双向链表中还可能包含指向前一个节点的引用）。在Java中，LinkedList既可以作为队列使用，也可以作为栈使用，它实现了List和Deque接口。

特点

1. 动态大小：链表的大小可以根据需要动态改变。
2. 非连续内存：链表的元素存储在分散的内存地址中，通过指针连接。
3. 插入和删除效率高：由于不需要移动大量元素，链表在插入和删除操作上比数组更高效。
4. 访问速度慢：链表不支持随机访问，访问特定元素需要从头开始遍历。

优点

1. 易于插入和删除元素。
2. 内存利用率高，因为不需要预先分配固定大小的内存空间。

缺点

1. 访问速度慢，不支持快速随机访问。
2. 需要额外的空间存储指向下一个节点的指针。

使用场景

1. 当你需要频繁插入和删除元素时。
2. 当你不知道数据的总量或者数据量会动态变化时。

java代码示例

public static void main(String[] args) {
    //1.创建链表
    LinkedList<Integer> list = new LinkedList<>();
        
    //2.添加元素
    // 2.1添加元素到链表末尾
    list.add(1);
    list.add(2);
    list.add(3);
    // 2.2添加元素到链表开头
    list.addFirst(0);
    // 2.3在指定位置插入元素
    list.add(1, 1); // 插入到索引1的位置删除元素：

    // 3删除链表的元素
    // 3.1删除链表末尾的元素
    list.removeLast();
    // 3.2删除链表开头的元素
    list.removeFirst();
    // 3.3删除指定元素
    list.remove(2); // 删除链表中值为2的元素
        
    //4.访问元素
    // 4.1获取链表中的元素
    Integer firstElement = list.getFirst();
    Integer lastElement = list.getLast();
    Integer elementAtPosition = list.get(1); // 获取索引为1的元素
    //4.2遍历链表：
    // 使用for-each循环遍历链表
    for (Integer num : list) {
        System.out.println(num);
    }
    // 4.3使用迭代器遍历链表
    Iterator<Integer> iterator = list.iterator();
    while (iterator.hasNext()) {
        Integer nextElement = iterator.next();
        System.out.println(nextElement);
    }
        
    //5获取链表大小：
    int size = list.size();
    System.out.println(size);
    }
}

链表是处理动态数据集合的理想选择，特别是在数据集合的插入和删除操作频繁时。

栈（Stack）

栈（Stack）是一种后进先出（Last In First Out, LIFO）的线性数据结构，它只允许在栈顶进行添加（push）和删除（pop）操作。在Java中，虽然没有直接提供栈的类，但可以使用java.util.Stack类或者自己实现一个栈。

特点

1. LIFO原则：最后添加的元素会最先被移除。
2. 操作限制：只能在栈顶进行添加和删除操作。
3. 简单性：栈的结构简单，易于实现和理解。

优点

1. 适用于解决需要后进先出的场景，如函数调用、表达式求值等。

缺点

1. 不能随机访问，无法直接访问栈中间的元素。
2. 大量数据的插入和删除可能导致性能问题。
   使用场景
3. 函数调用和递归实现。
4. 表达式求值，如算术表达式和逆波兰表达式。
5. 回溯算法，如迷宫求解、路径查找等。

java代码示例

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();

        // 向栈中添加元素（push）
        stack.push(1);
        stack.push(2);
        stack.push(3);

        // 移除并返回栈顶元素（pop）
        int poppedValue = stack.pop();
        System.out.println("Popped value: " + poppedValue); // 输出 3

        // 查看栈顶元素（peek）
        int topValue = stack.peek();
        System.out.println("Top value: " + topValue); // 输出 2

        // 检查栈是否为空
        boolean isEmpty = stack.isEmpty();
        System.out.println("Is stack empty? " + isEmpty); // 输出 false

        // 获取栈的大小
        int size = stack.size();
        System.out.println("Stack size: " + size); // 输出 2
    }
}

其实我们也可以自定义一个栈

public class MyStack {
    private int[] stackArray;
    private int top;
    private static final int INITIAL_SIZE = 10;

    public MyStack() {
        stackArray = new int[INITIAL_SIZE];
        top = -1;
    }

    public void push(int value) {
        if (top == stackArray.length - 1) {
            resize(stackArray.length * 2);
        }
        stackArray[++top] = value;
    }

    public int pop() {
        if (isEmpty()) {
            throw new IllegalStateException("Stack is empty.");
        }
        return stackArray[top--];
    }

    public int peek() {
        if (isEmpty()) {
            throw new IllegalStateException("Stack is empty.");
        }
        return stackArray[top];
    }

    public boolean isEmpty() {
        return top == -1;
    }

    public int size() {
        return top + 1;
    }

    private void resize(int newSize) {
        int[] oldArray = stackArray;
        stackArray = new int[newSize];
        System.arraycopy(oldArray, 0, stackArray, 0, oldArray.length);
    }
}

在这个自定义栈的实现中，我们使用了一个数组stackArray来存储栈中的元素，并用一个变量top来跟踪栈顶位置。push方法用于添加元素到栈顶，pop方法用于移除栈顶元素，peek方法用于查看栈顶元素而不移除它，isEmpty方法用于检查栈是否为空，size方法用于获取栈的大小。我们还提供了一个resize方法来处理栈的动态扩容。

队列（Queue）

队列（Queue）是一种遵循先进先出（First In First Out, FIFO）原则的线性数据结构。在Java中，java.util.Queue接口提供了队列的基本操作，而java.util.LinkedList类是实现Queue接口的一个常用选择。

特点

FIFO原则：最先添加的元素会最先被移除。
操作限制：在队列的前端（队头）进行删除操作，在后端（队尾）进行添加操作。
有序性：元素按照添加的顺序保持一致。

优点

1. 适用于解决需要按顺序处理数据的场景。
2. 可以有效地控制资源的分配和使用。

缺点

与栈相比，队列的操作可能稍慢，因为它需要维护元素的顺序。

使用场景

1. 任务调度和执行。
2. 缓冲区管理。
3. 广度优先搜索算法的实现。
   Java 代码示例

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();

        // 向队列中添加元素（enqueue）
        queue.add(1);
        queue.add(2);
        queue.add(3);

        // 移除并返回队列前端的元素（dequeue）
        int removedValue = queue.remove();
        System.out.println("Removed value: " + removedValue); // 输出 1

        // 查看队列前端的元素（peek）
        int frontValue = queue.peek();
        System.out.println("Front value: " + frontValue); // 输出 2

        // 检查队列是否为空
        boolean isEmpty = queue.isEmpty();
        System.out.println("Is queue empty? " + isEmpty); // 输出 false

        // 获取队列的大小
        int size = queue.size();
        System.out.println("Queue size: " + size); // 输出 2
    }
}

我们使用了java.util.LinkedList来创建一个队列。通过add方法向队列尾部添加元素，通过remove方法从队列头部移除元素。peek方法用于查看队列头部的元素而不移除它，isEmpty方法用于检查队列是否为空，size方法用于获取队列的大小。

队列是一种非常重要的数据结构，它在多线程编程、消息队列、任务调度等众多领域都有广泛的应用。

二叉搜索树Binary Search Tree）

二叉搜索树是一种特殊的二叉树，它具有以下特性：对于树中的任意节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这种结构使得二叉搜索树在查找、插入和删除操作上具有较好的性能。

特点

1. 有序性：BST中的节点值是有序的，这使得查找、插入和删除操作可以高效执行。
2. 动态结构：BST可以根据数据的插入和删除动态调整其结构。
3. 查找效率：平均情况下，查找操作的时间复杂度为O(log n)，最坏情况下为O(n)（当树退化为链表时）。

优点

1. 有序存储数据，便于快速查找、插入和删除。
2. 可以有效地进行中序遍历，获取有序的数据序列。

缺点

1. 当数据有序插入时，可能导致树高度不平衡，影响操作效率。
2. 需要额外的空间存储指针（左右子节点的引用）。

使用场景

1. 数据库索引。
2. 搜索引擎中的检索树。
3. 多路查找树的实现基础。

Java 代码示例

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val = x;
    }
}

public class BinarySearchTree {
    private TreeNode root;

    // 插入值
    public void insert(int value) {
        root = insertRec(root, value);
    }

    private TreeNode insertRec(TreeNode node, int value) {
        if (node == null) {
            return new TreeNode(value);
        }
        if (value < node.val) {
            node.left = insertRec(node.left, value);
        } else if (value > node.val) {
            node.right = insertRec(node.right, value);
        }
        return node;
    }

    // 查找值
    public boolean search(int value) {
        return searchRec(root, value);
    }

    private boolean searchRec(TreeNode node, int value) {
        if (node == null) {
            return false;
        }
        if (value == node.val) {
            return true;
        }
        return value < node.val ? searchRec(node.left, value) : searchRec(node.right, value);
    }

    // 中序遍历
    public void inorderTraversal() {
        inorderRec(root);
    }

    private void inorderRec(TreeNode node) {
        if (node != null) {
            inorderRec(node.left);
            System.out.print(node.val + " ");
            inorderRec(node.right);
        }
    }

    public static void main(String[] args) {
        BinarySearchTree bst = new BinarySearchTree();
        bst.insert(8);
        bst.insert(3);
        bst.insert(10);
        bst.insert(1);
        bst.insert(6);
        bst.insert(14);
        bst.insert(4);
        bst.insert(7);
        bst.insert(13);

        System.out.println("Inorder traversal of the given tree is:");
        bst.inorderTraversal(); // 输出应为：1 3 4 6 7 8 10 13 14
    }
}

一个TreeNode类来表示二叉搜索树的节点，BinarySearchTree类包含插入、查找和中序遍历的方法。insert方法用于向树中插入新的值，search方法用于查找树中是否存在某个值，inorderTraversal方法用于输出树的中序遍历结果。

图（Graph）

图（Graph）是一种复杂的数据结构，用于表示实体之间的多种关系。在图结构中，数据由节点（或称为顶点）和连接这些节点的边组成。图可以是无向的，也可以是有向的。在Java中，我们可以通过创建节点类和边类来表示图，并通过邻接列表或邻接矩阵来管理节点间的连接关系。

特点

1. 节点（Vertex）：图的基本单位，代表实体。
2. 边（Edge）：连接两个节点的线，代表实体间的关系。
3. 有向图（Directed Graph）：边有方向，表示从一个节点指向另一个节点。
4. 无向图（Undirected Graph）：边没有方向，表示节点间的双向关系。
5. 权重（Weight）：边可以带有权重，表示从一个节点到另一个节点的成本或距离。

优点

1. 能够表示复杂的关系和网络。
2. 适用于路径查找、网络流量分析等问题。

缺点

1. 管理和操作图结构可能比线性数据结构更复杂。
2. 某些操作（如图遍历）可能需要较高的时间和空间复杂度。

使用场景：

1. 社交网络分析。
2. 地图和导航系统。
3. 网络流量和互联网路由。

Java 代码示例

class Vertex {
    String label;

    Vertex(String label) {
        this.label = label;
    }
}

class Edge {
    Vertex from;
    Vertex to;
    int weight; // 可选属性，表示边的权重

    Edge(Vertex from, Vertex to, int weight) {
        this.from = from;
        this.to = to;
        this.weight = weight;
    }
}

class Graph {
    private List<Vertex> vertices;
    private List<Edge> edges;

    Graph() {
        vertices = new ArrayList<>();
        edges = new ArrayList<>();
    }

    void addVertex(Vertex v) {
        vertices.add(v);
    }

    void addEdge(Edge e) {
        edges.add(e);
    }

    // 打印图的节点和边
    void printGraph() {
        System.out.println("Vertices: " + vertices);
        System.out.println("Edges: " + edges);
    }

    // 示例：添加节点和边
    public static void main(String[] args) {
        Graph g = new Graph();

        Vertex v1 = new Vertex("A");
        Vertex v2 = new Vertex("B");
        Vertex v3 = new Vertex("C");

        g.addVertex(v1);
        g.addVertex(v2);
        g.addVertex(v3);

        Edge e1 = new Edge(v1, v2, 1); // A -> B with weight 1
        Edge e2 = new Edge(v2, v3, 2); // B -> C with weight 2
        Edge e3 = new Edge(v3, v1, 3); // C -> A with weight 3

        g.addEdge(e1);
        g.addEdge(e2);
        g.addEdge(e3);

        g.printGraph();
    }
}

Vertex类来表示图中的节点，Edge类来表示连接两个节点的边，并且可以包含边的权重。Graph类包含一个顶点列表和一个边列表，用于管理图的节点和边。addVertex方法用于向图中添加节点，addEdge方法用于添加边。printGraph方法用于打印当前图的节点和边。

通过上述代码示例，我们可以创建一个简单的无向图，并对其进行基本操作。在实际应用中，图结构可以用于实现更复杂的算法，如图遍历（深度优先搜索DFS和广度优先搜索BFS）、最短路径查找（如Dijkstra算法）等。

总结

掌握不同的数据结构对于程序员来说至关重要。它们不仅影响代码的性能，还决定了算法的效率。了解每种数据结构的特性和适用场景，能够帮助我们在面对复杂问题时，选择最合适的解决方案。在实际编程中，合理地使用数据结构，可以使我们的代码更加清晰、高效和可维护。