数据结构Demo及其适用场景

1、数组（Array）：适用于需要按索引随机访问元素的场景，例如需要高效地获取、修改和遍历元素的情况，以下是demo:

// 创建一个整数数组
int[] arr = new int[5];

// 在特定索引位置设置元素的值
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;

// 获取特定索引位置的元素值
int value = arr[1]; // value = 20

// 遍历数组并打印元素
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

2、链表（Linked List）：适用于需要频繁插入和删除元素的场景，因为插入和删除操作只需要调整节点的指针，而不需要移动其他元素，以下是demo

// 定义链表节点类
class ListNode {
    int val;
    ListNode next;

    public ListNode(int val) {
        this.val = val;
        this.next = null;
    }
}

// 创建链表
ListNode head = new ListNode(1);
ListNode node2 = new ListNode(2);
ListNode node3 = new ListNode(3);

// 建立节点之间的连接关系
head.next = node2;
node2.next = node3;

// 遍历链表并打印节点值
ListNode curr = head;
while (curr != null) {
    System.out.println(curr.val);
    curr = curr.next;
}

3、栈（Stack）：适用于需要实现后进先出（LIFO）操作的场景，例如函数调用的追踪、表达式求值和撤销操作等，以下是demo

import java.util.Stack;

// 创建一个整数栈
Stack<Integer> stack = new Stack<>();

// 入栈
stack.push(10);
stack.push(20);
stack.push(30);

// 出栈
int top = stack.pop(); // top = 30

// 获取栈顶元素但不出栈
int peek = stack.peek(); // peek = 20

// 判断栈是否为空
boolean isEmpty = stack.isEmpty(); // isEmpty = false

4、队列（Queue）：适用于需要实现先进先出（FIFO）操作的场景，例如任务调度、消息传递和缓冲区管理等，以下是demo

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

// 创建一个整数队列
Queue<Integer> queue = new LinkedList<>();

// 入队
queue.offer(10);
queue.offer(20);
queue.offer(30);

// 出队
int front = queue.poll(); // front = 10

// 获取队首元素但不出队
int peek = queue.peek(); // peek = 20

// 判断队列是否为空
boolean isEmpty = queue.isEmpty(); // isEmpty = false

5、树（Tree）：适用于具有层次关系的数据组织和搜索场景，例如文件系统、组织结构和编译器的语法分析等，以下是demo

// 定义树节点类
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

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

// 创建一棵二叉树
TreeNode root = new TreeNode(1);
TreeNode leftChild = new TreeNode(2);
TreeNode rightChild = new TreeNode(3);

// 建立节点之间的连接关系
root.left = leftChild;
root.right = rightChild;

// 遍历二叉树（先序遍历）
void preOrderTraversal(TreeNode node) {
    if (node == null) return;
    
    System.out.println(node.val);
    preOrderTraversal(node.left);
    preOrderTraversal(node.right);
}

preOrderTraversal(root);

6、图（Graph）：适用于表示和解决各种关系型问题的场景，例如社交网络分析、路径搜索和网络拓扑结构等，以下是demo

import java.util.List;
import java.util.ArrayList;

// 定义图节点类
class GraphNode {
    int val;
    List<GraphNode> neighbors;

    public GraphNode(int val) {
        this.val = val;
        this.neighbors = new ArrayList<>();
    }
}

// 创建一个有向图
GraphNode node1 = new GraphNode(1);
GraphNode node2 = new GraphNode(2);
GraphNode node3 = new GraphNode(3);

// 建立节点之间的连接关系
node1.neighbors.add(node2);
node2.neighbors.add(node3);
node3.neighbors.add(node1);

// 遍历图（深度优先遍历）
void depthFirstTraversal(GraphNode node, boolean[] visited) {
    visited[node.val] = true;
    System.out.println(node.val);

    for (GraphNode neighbor : node.neighbors) {
        if (!visited[neighbor.val]) {
            depthFirstTraversal(neighbor, visited);
        }
    }
}

boolean[] visited = new boolean[n]; // n 为节点数量
depthFirstTraversal(node1, visited);

7、堆（Heap）：适用于需要高效地找到最大或最小元素的场景，例如优先队列和排序算法（如堆排序），已下是demo

import java.util.PriorityQueue;

// 创建一个最小堆
PriorityQueue<Integer> minHeap = new PriorityQueue<>();

// 插入元素到堆中
minHeap.offer(10);
minHeap.offer(20);
minHeap.offer(5);

// 获取堆顶元素（最小值）但不删除
int min = minHeap.peek(); // min = 5

// 删除堆顶元素（最小值）
int removedElement = minHeap.poll(); // removedElement = 5

// 判断堆是否为空
boolean isEmpty = minHeap.isEmpty(); // isEmpty = false

8、散列表（Hash Table）：适用于需要快速查找和插入的场景，通过散列函数将关键字映射到存储位置，例如字典、缓存和唯一标识符的快速查找，一下是demo

import java.util.HashMap;

// 创建一个散列表
HashMap<String, Integer> hashMap = new HashMap<>();

// 插入键值对到散列表中
hashMap.put("key1", 10);
hashMap.put("key2", 20);
hashMap.put("key3", 30);

// 获取特定键的值
int value = hashMap.get("key2"); // value = 20

// 检查键是否存在于散列表中
boolean containsKey = hashMap.containsKey("key3"); // containsKey = true

// 删除特定键的键值对
int removedValue = hashMap.remove("key1"); // removedValue = 10

// 判断散列表是否为空
boolean isEmpty = hashMap.isEmpty(); // isEmpty = false