Java常见数据结构

最新推荐文章于 2024-08-23 23:51:56 发布

需要重新演唱

最新推荐文章于 2024-08-23 23:51:56 发布

阅读量686

点赞数 3

文章标签： java 数据结构开发语言

本文链接：https://blog.csdn.net/xycxycooo/article/details/140743382

版权

在Java中，数据结构是用于存储和组织数据的方式，它们在不同的场景下有着不同的性能和用途。常见的数据结构包括数组、链表、栈、队列、树、图等。下面我们将详细讲解Java中常见的数据结构，并通过示例代码来帮助大家更好地理解。

1. 数组（Array）

概念解释：
数组是一种线性数据结构，用于存储一组相同类型的元素。数组在内存中是连续存储的，通过下标访问元素，访问速度快。

特点：

固定大小：数组一旦创建，大小不可改变。
随机访问：通过下标可以快速访问元素。

示例代码：

public class ArrayExample {
    public static void main(String[] args) {
        int[] array = new int[5];
        array[0] = 10;
        array[1] = 20;
        array[2] = 30;
        array[3] = 40;
        array[4] = 50;

        for (int i = 0; i < array.length; i++) {
            System.out.println("Element at index " + i + ": " + array[i]);
        }
    }
}

在这个示例中，我们创建了一个大小为5的整数数组，并通过下标访问和修改元素。

2. 链表（Linked List）

概念解释：
链表是一种动态数据结构，由节点组成，每个节点包含数据和指向下一个节点的引用。链表在内存中不是连续存储的，插入和删除操作效率高。

特点：

动态大小：链表大小可以动态改变。
插入和删除效率高：不需要移动其他元素。

示例代码：

public class LinkedListExample {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("Apple");
        linkedList.add("Banana");
        linkedList.add("Cherry");

        for (String fruit : linkedList) {
            System.out.println(fruit);
        }
    }
}

在这个示例中，我们使用Java提供的 LinkedList 类来创建和操作链表。

3. 栈（Stack）

概念解释：
栈是一种后进先出（LIFO）的数据结构，只允许在栈顶进行插入和删除操作。

特点：

后进先出：最后插入的元素最先被删除。
常用操作：push（入栈）、pop（出栈）、peek（查看栈顶元素）。

示例代码：

import java.util.Stack;

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

        while (!stack.isEmpty()) {
            System.out.println("Popped: " + stack.pop());
        }
    }
}

在这个示例中，我们使用Java提供的 Stack 类来创建和操作栈。

4. 队列（Queue）

概念解释：
队列是一种先进先出（FIFO）的数据结构，只允许在队尾插入元素，在队头删除元素。

特点：

先进先出：最先插入的元素最先被删除。
常用操作：offer（入队）、poll（出队）、peek（查看队头元素）。

示例代码：

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

public class QueueExample {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.offer("Alice");
        queue.offer("Bob");
        queue.offer("Charlie");

        while (!queue.isEmpty()) {
            System.out.println("Polled: " + queue.poll());
        }
    }
}

在这个示例中，我们使用Java提供的 Queue 接口和 LinkedList 实现类来创建和操作队列。

5. 树（Tree）

概念解释：
树是一种非线性数据结构，由节点组成，每个节点可以有多个子节点。常见的树结构包括二叉树、二叉搜索树、平衡树等。

特点：

层次结构：节点之间有明确的父子关系。
常用操作：插入、删除、查找。

示例代码：

class TreeNode {
    int value;
    TreeNode left;
    TreeNode right;

    TreeNode(int value) {
        this.value = value;
        left = null;
        right = null;
    }
}

public class BinaryTreeExample {
    public static void main(String[] args) {
        TreeNode root = new TreeNode(10);
        root.left = new TreeNode(5);
        root.right = new TreeNode(15);
        root.left.left = new TreeNode(3);
        root.left.right = new TreeNode(7);

        System.out.println("Inorder traversal:");
        inorderTraversal(root);
    }

    public static void inorderTraversal(TreeNode node) {
        if (node != null) {
            inorderTraversal(node.left);
            System.out.print(node.value + " ");
            inorderTraversal(node.right);
        }
    }
}

在这个示例中，我们定义了一个简单的二叉树，并实现了中序遍历。

6. 图（Graph）

概念解释：
图是一种非线性数据结构，由节点（顶点）和边组成，节点之间可以有多个连接。图可以分为有向图和无向图。

特点：

复杂关系：节点之间可以有复杂的多对多关系。
常用操作：深度优先搜索（DFS）、广度优先搜索（BFS）。

示例代码：

import java.util.*;

class Graph {
    private int V;
    private LinkedList<Integer>[] adj;

    Graph(int v) {
        V = v;
        adj = new LinkedList[v];
        for (int i = 0; i < v; ++i) {
            adj[i] = new LinkedList<>();
        }
    }

    void addEdge(int v, int w) {
        adj[v].add(w);
    }

    void BFS(int s) {
        boolean[] visited = new boolean[V];
        LinkedList<Integer> queue = new LinkedList<>();
        visited[s] = true;
        queue.add(s);

        while (queue.size() != 0) {
            s = queue.poll();
            System.out.print(s + " ");

            for (Integer n : adj[s]) {
                if (!visited[n]) {
                    visited[n] = true;
                    queue.add(n);
                }
            }
        }
    }
}

public class GraphExample {
    public static void main(String[] args) {
        Graph g = new Graph(4);
        g.addEdge(0, 1);
        g.addEdge(0, 2);
        g.addEdge(1, 2);
        g.addEdge(2, 0);
        g.addEdge(2, 3);
        g.addEdge(3, 3);

        System.out.println("Breadth First Traversal (starting from vertex 2):");
        g.BFS(2);
    }
}