文章目录

[数据结构概述](#数据结构概述)
常见的数据结构
示例

数据结构概述

数据结构是一种组织和存储数据的方式，它描述了数据元素之间的相互关系以及数据元素的组织形式。数据结构基本概念包括数据、数据元素和数据项、数据对象、数据结构、逻辑结构和存储结构。数据是指能够被计算机识别、存储、计算（处理）的符号集合，而数据元素也称作节点，是数据的基本单位，最小单位是数据项。数据对象是具有相同特征的数据元素的集合，是数据的子集。

数据结构是计算机存储、组织数据的方式，它分为数据的逻辑结构和存储结构。逻辑结构是指从逻辑关系上描述数据，与数据的存储无关，且独立于语言。存储结构是指数据元素及其关系在计算机存储时如何表示，依赖于语言。根据数据的逻辑关系，可以将数据结构分为线性结构和非线性结构。线性结构包括集合结构、线性结构和双线性结构，这些结构中的元素存在一对一的相互关系。而非线性结构包括树形结构和图形结构，这些结构中的元素存在一对多或多对多的相互关系。

总之，数据结构是计算机中用于管理和处理数据的一种方法，它有助于提高数据处理效率和精度。

常见的数据结构

Java 中常见的数据结构主要有以下几种：

数组（Array）：数组是一种线性表数据结构，可以存储同一类型的元素集合。在 Java 中，数组可以通过声明和初始化来创建。
链表（LinkedList）：链表是一种线性表数据结构，可以存储不同类型的元素集合。在 Java 中，链表可以通过 LinkedList 类来实现。
栈（Stack）：栈是一种后进先出（LIFO）的数据结构，可以存储不同类型的元素集合。在 Java 中，栈可以通过 Stack 类来实现。
队列（Queue）：队列是一种先进先出（FIFO）的数据结构，可以存储不同类型的元素集合。在 Java 中，队列可以通过 Queue 接口和它的实现类（如 LinkedList）来实现。
集合（Set）：集合是一种不允许重复元素的数据结构，可以存储不同类型的元素集合。在 Java 中，集合可以通过 Set 接口和它的实现类（如 HashSet）来实现。
映射（Map）：映射是一种键值对（key-value pair）的数据结构，可以存储不同类型的元素集合。在 Java 中，映射可以通过 Map 接口和它的实现类（如 HashMap）来实现。
树（Tree）：树是一种非线性的数据结构，可以存储不同类型的元素集合。在 Java 中，树可以通过 Tree 接口和它的实现类（如 BinaryTree）来实现。
图（Graph）：图是一种非线性的数据结构，可以存储不同类型的元素集合。在 Java 中，图可以通过 Graph 接口和它的实现类（如 SimpleGraph）来实现。

示例

（一）数组（Array）

在Java中，数组是一种简单的数据结构，用于存储固定大小的相同类型的元素集合。以下是一个Java数组的示例：

java 复制代码

public class ArrayExample {
    public static void main(String[] args) {
        // 声明一个包含5个整数的数组
        int[] numbers = new int[5];

        // 通过索引访问和修改数组元素
        numbers[0] = 10;
        numbers[1] = 20;
        numbers[2] = 30;
        numbers[3] = 40;
        numbers[4] = 50;

        // 打印数组中的元素
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("Element at index " + i + " : " + numbers[i]);
        }

        // 声明并初始化一个字符串数组
        String[] words = {"Hello", "World", "Java", "Array", "Example"};

        // 使用增强for循环打印数组中的元素
        for (String word : words) {
            System.out.println(word);
        }
    }
}

在这个例子中，我们首先声明了一个包含5个整数的数组numbers，然后通过索引访问和修改数组中的元素。接下来，我们使用一个for循环遍历数组并打印出每个元素。然后我们声明并初始化了一个字符串数组words，并使用增强for循环打印出数组中的元素。

（二）链表（LinkedList）

在Java中，链表是一种常见的数据结构，它是一系列节点的集合，每个节点包含两个部分：数据和指向下一个节点的引用。下面是一个简单的单向链表的示例：

java 复制代码

public class LinkedList {
    
    // 链表节点类
    private static class Node {
        int data;
        Node next;

        public Node(int data) {
            this.data = data;
            this.next = null;
        }
    }

    // 头节点
    private Node head;

    // 向链表添加节点
    public void add(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
        } else {
            Node current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
        }
    }

    // 打印链表
    public void printList() {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " ");
            current = current.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.add(1);
        linkedList.add(2);
        linkedList.add(3);
        linkedList.add(4);
        linkedList.add(5);
        linkedList.printList(); // 输出：1 2 3 4 5 
    }
}

上面的示例代码定义了一个简单的链表类LinkedList。它包含一个内部类Node，用于表示链表中的节点。每个节点包含一个整数值和一个指向下一个节点的引用。链表类有一个头节点head，它指向链表的第一个节点。add方法用于向链表末尾添加新节点，而printList方法用于打印链表的内容。main方法创建了一个LinkedList对象，向其添加了几个节点，然后打印出链表的内容。

（三）栈（Stack）

在Java中，栈是一种数据结构，它遵循LIFO（后进先出）原则。这意味着最后一个被添加到栈中的元素将是第一个被移除的元素。Java的java.util.Stack类提供了栈的实现。

以下是一个简单的Java程序，它演示了如何使用Stack类：

java 复制代码

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        // 创建一个新的Stack实例
        Stack<Integer> stack = new Stack<>();

        // 使用push方法向栈中添加元素
        stack.push(1);
        stack.push(2);
        stack.push(3);
        System.out.println("当前栈: " + stack);

        // 使用peek方法查看栈顶元素，不移除
        int top = stack.peek();
        System.out.println("栈顶元素: " + top);
        System.out.println("执行peek操作后的栈: " + stack);

        // 使用pop方法移除栈顶元素
        top = stack.pop();
        System.out.println("被移除的元素: " + top);
        System.out.println("执行pop操作后的栈: " + stack);

        // 使用isEmpty方法检查栈是否为空
        boolean empty = stack.isEmpty();
        System.out.println("栈是否为空: " + empty);
    }
}

这个示例展示了如何使用push方法将元素添加到栈中，使用peek方法查看（但不移除）栈顶元素，使用pop方法移除栈顶元素，以及使用isEmpty方法检查栈是否为空。

（四）队列（Queue）

在Java中，队列（Queue）是一种特殊类型的线性表，新元素总是在队列的末端添加，而删除操作总是在队列的开始进行。这样，队列中的元素总是先进先出（FIFO）。

下面是一个简单的Java程序，演示了如何使用Java的内置Queue接口以及它的实现类LinkedList：

java 复制代码

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

public class QueueExample {
    public static void main(String[] args) {
        // 创建一个队列
        Queue<Integer> queue = new LinkedList<>();

        // 添加元素到队列
        for (int i = 1; i <= 5; i++) {
            queue.add(i);
        }

        // 显示队列的元素
        System.out.println("Elements in queue: " + queue);

        // 删除队列的头元素
        int removedElement = queue.remove();
        System.out.println("Removed element: " + removedElement);

        // 查看队列的头元素，但不删除
        int headElement = queue.peek();
        System.out.println("Head of queue: " + headElement);

        // 查看队列的大小
        int size = queue.size();
        System.out.println("Size of queue: " + size);
    }
}

在这个示例中，我们创建了一个整数类型的队列，并使用LinkedList实现。我们添加了一些元素，并显示了队列的内容。然后我们删除了队列的头元素，并再次显示了队列的内容。我们还查看了队列的头元素，但没有删除它，并查看了队列的大小。

这个示例只展示了Java的Queue接口的基本功能。在实际应用中，可能会使用更复杂的操作，例如优先队列（PriorityQueue）或者阻塞队列（BlockingQueue）等。

（五）集合（Set）

在Java中，Set是一种集合，它不允许包含重复元素，并且最多包含一个null元素。以下是使用Java中Set的示例：

java 复制代码

import java.util.HashSet;
import java.util.Set;

public class SetExample {
    public static void main(String[] args) {
        // 创建一个新的Set对象
        Set<String> set = new HashSet<>();

        // 添加元素到Set中
        set.add("A");
        set.add("B");
        set.add("C");
        set.add("D");

        // 输出Set的大小
        System.out.println("Size of set: " + set.size());

        // 检查一个元素是否在Set中
        System.out.println("Contains A? " + set.contains("A"));

        // 遍历并打印Set中的所有元素
        for (String element : set) {
            System.out.println(element);
        }

        // 删除一个元素
        set.remove("B");

        // 打印删除后的Set
        System.out.println("After removing B: " + set);
    }
}

在这个例子中，创建了一个HashSet，这是Set接口的一种实现。然后向这个Set添加了一些字符串元素，并检查了一个元素是否存在于Set中。遍历并打印了Set中的所有元素，然后删除了一个元素并打印了删除后的Set。

（六）映射（Map）

在Java中，Map是一种数据结构，可以存储键值对，其中键是唯一的。Map的常用实现类包括HashMap、TreeMap和LinkedHashMap等。以下是使用Java中Map的示例：

java 复制代码

import java.util.HashMap;
import java.util.Map;

public class MapExample {
    public static void main(String[] args) {
        // 创建一个新的Map对象
        Map<String, Integer> map = new HashMap<>();

        // 向Map中添加元素
        map.put("Alice", 25);
        map.put("Bob", 30);
        map.put("Charlie", 35);

        // 获取Map中的元素
        int age = map.get("Bob");
        System.out.println("Bob's age is " + age);

        // 检查Map中是否包含某个键
        boolean containsKey = map.containsKey("Charlie");
        System.out.println("Map contains Charlie's key: " + containsKey);

        // 遍历Map中的所有键值对
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            String name = entry.getKey();
            int age = entry.getValue();
            System.out.println(name + " is " + age + " years old.");
        }

        // 删除Map中的元素
        map.remove("Alice");
        System.out.println("After removing Alice: " + map);
    }
}

在这个示例中，使用了一个HashMap来存储人名和对应的年龄。向Map中添加了一些元素，并使用get方法获取了其中一个元素的值。还使用containsKey方法检查了Map中是否包含某个键，并使用entrySet方法遍历了Map中的所有键值对。最后，使用remove方法删除了Map中的一个元素。

（七）树（Tree）

在Java中，树是一种非线性的数据结构，它用于表示具有层次关系的数据。每个树都由一个根节点和零个或多个子树组成，每个子树也是一个树。以下是一个简单的Java示例，演示了如何定义一个基本的树结构：

java 复制代码

// 定义一个树结构节点
class TreeNode {
    int value;
    TreeNode left;
    TreeNode right;

    // 构造方法
    TreeNode(int value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }
}

// 定义一个二叉树
public class BinaryTree {
    TreeNode root;

    // 构造方法
    BinaryTree(int value) {
        root = new TreeNode(value);
    }

    // 为了简单起见，这个例子中我们将只打印树的根节点值
    public void printRootValue() {
        System.out.println("Root Value: " + root.value);
    }

    public static void main(String[] args) {
        // 创建一个新的二叉树
        BinaryTree tree = new BinaryTree(1);

        // 打印根节点的值
        tree.printRootValue();
    }
}

在这个例子中，创建了一个二叉树，也就是说每个节点最多有两个子节点（可能为零个，即该节点为叶子节点）。每个节点有一个值，以及指向其左右子节点的引用。还定义了一个方法来打印树的根节点的值。当然，实际使用中，可能需要更多的方法来操作树，比如插入新节点、删除节点、搜索值等等。

（八）图（Graph）

在Java中，图（Graph）是一种常见的数据结构，用于表示对象之间的关系。下面是一个简单的示例，演示了如何使用Java实现一个图数据结构：

首先，需要定义图的基本元素：顶点和边。

定义顶点类 Vertex：

java 复制代码

public class Vertex {
    private String label;
    private int index;

    public Vertex(String label, int index) {
        this.label = label;
        this.index = index;
    }

    public String getLabel() {
        return label;
    }

    public int getIndex() {
        return index;
    }
}

定义边类 Edge：

java 复制代码

public class Edge {
    private Vertex from;
    private Vertex to;
    private int weight;

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

    public Vertex getFrom() {
        return from;
    }

    public Vertex getTo() {
        return to;
    }

    public int getWeight() {
        return weight;
    }
}

接下来，定义一个图类 Graph，并在其中实现图的基本操作：添加顶点、添加边、打印图等。

定义图类 Graph：

java 复制代码

import java.util.*;

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

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

    public void addVertex(Vertex vertex) {
        vertices.add(vertex);
    }

    public void addEdge(Edge edge) {
        edges.add(edge);
    }

    public void printGraph() {
        System.out.println("Vertices:");
        for (Vertex vertex : vertices) {
            System.out.println("Label: " + vertex.getLabel() + ", Index: " + vertex.getIndex());
        }
        System.out.println("Edges:");
        for (Edge edge : edges) {
            System.out.println("From: " + edge.getFrom().getLabel() + ", To: " + edge.getTo().getLabel() + ", Weight: " + edge.getWeight());
        }
    }
}

现在，可以创建一个图并对其进行操作：

主类 Main：

java 复制代码

public class Main {
    public static void main(String[] args) {
        Graph graph = new Graph();
        Vertex v1 = new Vertex("A", 0);
        Vertex v2 = new Vertex("B", 1);
        Vertex v3 = new Vertex("C", 2);
        graph.addVertex(v1);
        graph.addVertex(v2);
        graph.addVertex(v3);
        graph.addEdge(new Edge(v1, v2, 1));
        graph.addEdge(new Edge(v2, v3, 2));
        graph.addEdge(new Edge(v3, v1, 3));
        graph.printGraph();
    }
}

在这个例子中，创建了一个简单的无向图，其中包含三个节点A、B和C，以及三条边连接它们。边的权重分别表示从A到B的距离为1，从B到C的距离为2，以及从C到A的距离为3。这些权重可以解释为任意两个节点之间的距离，例如，节点A和节点B之间的距离为1，节点B和节点C之间的距离为2，以此类推。

为了完整地表示这个图，可以使用邻接矩阵来表示它。邻接矩阵是一个二维数组，其中行和列都表示图中的节点，矩阵中的元素表示两个节点之间是否有边相连，以及边的权重。在这个例子中，邻接矩阵可以如下所示：

A B C
A 0 1 3
B 1 0 2
C 3 2 0

其中第一行第二列的元素为1，表示从A到B有一条权重为1的边；第二行第三列的元素为2，表示从B到C有一条权重为2的边；以此类推。

除了邻接矩阵之外，还可以使用邻接列表来表示图。邻接列表是一个数组，其中每个元素都表示一个节点及其相邻的节点和边。例如，对于上面的图，邻接列表可以如下所示：

css 复制代码

A: B(1) C(3)
B: A(1) C(2)
C: A(3) B(2)

其中第一行的第一个元素A表示起点节点，后面的冒号后跟着它的相邻节点和相应的边的权重。例如，从A到B有一条权重为1的边，从A到C有一条权重为3的边。以此类推，对于其他节点也是如此。

Java 复习笔记 - 集合进阶篇：数据结构

文章目录

数据结构 概述

常见的数据结构

示例

（一）数组（Array）

（二）链表（LinkedList）

（三）栈（Stack）

（四）队列（Queue）

（五）集合（Set）

（六）映射（Map）

（七）树（Tree）

（八）图（Graph）

数据结构概述