Java八股文（数据结构）

数据结构

1. 请解释以下数据结构的概念：链表、栈、队列和树。

链表是一种线性数据结构，由节点组成，每个节点包含了指向下一个节点的指针；
栈是一种后进先出（LIFO）的数据结构，只能在一端进行插入和删除操作；
队列是一种先进先出（FIFO）的数据结构，一端进行插入操作，在另一端进行删除操作；
树是一种非线性数据结构，由节点和边组成，其中父节点可以有多个子节点。

2. 请解释下面时间复杂度符号的含义：O(1)、O(log n)、O(n)和O(n^2)。

O(1)表示算法的执行时间不随输入规模变化；
O(log n)表示算法的执行时间随输入规模的增加而增加，但增加速度较慢；
O(n)表示算法的执行时间与输入规模成正比；
O(n^2)表示算法的执行时间与输入规模的平方成正比。

3. 请解释什么是二分查找，并提供一个二分查找的实现。

二分查找是一种在有序数组中查找元素的算法，每次都将区间缩小为原来的一半，直到找到目标元素或无法再缩小。
以下是一个二分查找的实现（Java）：

public int binarySearch(int[] arr, int target) {
   
    int left = 0;
    int right = arr.length - 1;
    while (left <= right) {
   
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) {
   
            return mid;
        } else if (arr[mid] < target) {
   
            left = mid + 1;
        } else {
   
            right = mid - 1;
        }
    }
    return -1;
}

4. 请解释什么是哈希表，并提供一个哈希函数的示例。

哈希表是一种基于哈希函数的数据结构，用于存储和查找键值对。
哈希函数将键映射为一个固定大小的数组索引，使得在查找或插入时可以快速定位。
以下是一个哈希函数的示例（Java）：

public int hashFunction(String key) {
   
    int hash = 0;
    for (int i = 0; i < key.length(); i++) {
   
        hash = (hash + key.charAt(i) - 'a') % tableSize;
    }
    return hash;
}

在此示例中，假设我们将英文字母映射为整数，'a’对应0，'b’对应1，以此类推。

5. 请解释什么是二叉树，并提供一个二叉树的遍历实现（前序、中序和后序）。

二叉树是一种特殊的树结构，每个节点最多有两个子节点，称为左子节点和右子节点。
以下是二叉树的前序、中序和后序遍历的实现（Java）：

// 前序遍历（根-左-右）
public void preOrderTraversal(TreeNode root) {
   
    if (root == null) {
   
        return;
    }
    System.out.println(root.val);
    preOrderTraversal(root.left);
    preOrderTraversal(root.right);
}

// 中序遍历（左-根-右）
public void inOrderTraversal(TreeNode root) {
   
    if (root == null) {
   
        return;
    }
    inOrderTraversal(root.left);
    System.out.println(root.val);
    inOrderTraversal(root.right);
}

// 后序遍历（左-右-根）
public void postOrderTraversal(TreeNode root) {
   
    if (root == null) {
   
        return;
    }
    postOrderTraversal(root.left);
    postOrderTraversal(root.right);
    System.out.println(root.val);
}

这里的TreeNode是二叉树的节点类，包含一个值val和左右子节点的引用。

6. 请解释什么是图，并提供一种图的表示方法。

图是一种非线性数据结构，由节点（顶点）和边组成，表示顶点之间的关系。
常用的图的表示方法有邻接矩阵和邻接表。
邻接矩阵使用二维数组表示节点之间的连接关系，而邻接表则使用链表数组表示每个节点的邻居。

7. 请解释什么是堆，并提供一个堆的实现。

堆是一种完全二叉树，分为最大堆和最小堆。
最大堆中，每个父节点的值都大于或等于其子节点的值；
最小堆中，每个父节点的值都小于或等于其子节点的值。
以下是一个最大堆的实现（Java）：

class MaxHeap {
   
    private int[] heap;
    private int size;
    
    public MaxHeap(int capacity) {
   
        heap = new int[capacity];
        size = 0;
    }
    
    public void insert(int value) {
   
        if (size == heap.length) {
   
            throw new IllegalStateException("Heap is full");
        }
        
        heap[size] = value;
        siftUp(size);
        size++;
    }
    
    private void siftUp(int index) {
   
        while (index > 0 && heap[index] > heap[parentIndex(index)]) {
   
            swap(index, parentIndex(index));
            index = parentIndex(index);
        }
    }
    
    public int removeMax() {
   
        if (size == 0) {
   
            throw new IllegalStateException("Heap is empty");
        }
        
        int max = heap[0];
        heap[0] = heap[size - 1];
        size--;
        siftDown(0);
        return max;
    }
    
    private void siftDown(int index) {
   
        while (leftChildIndex(index) < size) {
   
            int maxIndex = leftChildIndex(index);
            if (rightChildIndex(index) < size && heap[rightChildIndex(index)] > heap[leftChildIndex(index)]) {
   
                maxIndex = rightChildIndex(index);
            }
            if (heap[index] >= heap[maxIndex]) {
   
                break;
            }
            swap(index, maxIndex);
            index = maxIndex;
        }
    }
    
    // Helper methods for calculating parent and child indices
    private int parentIndex(int index) {
   
        return (index - 1) / 2;
    }
    
    private int leftChildIndex(int index) {
   
        return 2 * index + 1;
    }
    
    private int rightChildIndex(int index) {
   
        return 2 * index + 2;
    }
    
    private void swap(int index1, int index2) {
   
        int temp = heap[index1];
        heap[index1] = heap[index2];
        heap[index2] = temp;
    }
}

该堆类提供了插入和删除最大值的操作，并保持了堆的性质。

8. 请解释什么是哈夫曼树，并提供一个哈夫曼编码的实现。

哈夫曼树是一种用于数据编码的树结构，用于将频率较高的字符编码为较短的二进制码，以实现更高的压缩比。
哈夫曼编码的实现需要构建哈夫曼树，并通过DFS遍历树来生成每个字符的编码。
以下是一个哈夫曼编码的实现（Java）：

class HuffmanNode implements Comparable<HuffmanNode> {
   
    char value;
    int frequency;
    HuffmanNode left;
    HuffmanNode right;
    
    public HuffmanNode(char value, int frequency) {
   
        this.value = value;
        this.frequency = frequency;
    }
    
    @Override
    public int compareTo(HuffmanNode other) {
   
        return this.frequency - other.frequency;
    }
}

public String huffmanEncode(String text) {
   
    if (text.isEmpty()) {
   
        return "";
    }
    
    // Calculate character frequencies
    Map<Character, Integer> frequencies = new HashMap<>();
    for (char c : text.toCharArray()) {
   
        frequencies.put(c, frequencies.getOrDefault(c, 0) + 1);
    }
    
    // Build Huffman tree
    PriorityQueue<HuffmanNode> pq = new PriorityQueue<>();
    for (Map.Entry<Character, Integer> entry : frequencies.entrySet()) {
   
        pq.offer(new HuffmanNode(entry.getKey(), entry.getValue()));
    }
    while (pq.size() > 1) {
   
        HuffmanNode left = pq.poll();