Java函数实现数据结构（栈、队列、堆、树）的经典算法

栈、队列、堆和树是数据结构中非常常见的四种基本结构，它们都有自己的经典算法。以下是使用Java实现这些数据结构及其经典算法的示例代码。

1. 栈：

栈是一种后进先出（LIFO）的数据结构。在Java中，我们可以使用Java集合框架中的LinkedList类来实现栈，通过push方法添加元素，并通过pop方法弹出元素。

import java.util.LinkedList;

class Stack {
  private LinkedList<Integer> stack;
  
  public Stack() {
    stack = new LinkedList<Integer>();
  }

  public void push(int value) {
    stack.addLast(value);
  }

  public int pop() {
    return stack.removeLast();
  }
  
  public int peek() {
    return stack.getLast();
  }
  
  public boolean isEmpty() {
    return stack.isEmpty();
  }
}

// 使用示例
Stack stack = new Stack();
stack.push(1);
stack.push(2);
stack.push(3);
System.out.println(stack.pop()); // 输出3
System.out.println(stack.peek()); // 输出2
System.out.println(stack.isEmpty()); // 输出false

2. 队列：

队列是一种先进先出（FIFO）的数据结构。在Java中，可以使用LinkedList类来实现队列，通过offer方法添加元素，并通过poll方法获取并移除队首元素。

import java.util.LinkedList;

class Queue {
  private LinkedList<Integer> queue;
  
  public Queue() {
    queue = new LinkedList<Integer>();
  }

  public void offer(int value) {
    queue.addLast(value);
  }

  public int poll() {
    return queue.removeFirst();
  }
  
  public int peek() {
    return queue.getFirst();
  }
  
  public boolean isEmpty() {
    return queue.isEmpty();
  }
}

// 使用示例
Queue queue = new Queue();
queue.offer(1);
queue.offer(2);
queue.offer(3);
System.out.println(queue.poll()); // 输出1
System.out.println(queue.peek()); // 输出2
System.out.println(queue.isEmpty()); // 输出false

3. 堆：

堆是一种可以快速找到最小（或最大）元素的数据结构。在Java中，可以使用PriorityQueue类来实现堆，默认情况下使用小顶堆。

import java.util.PriorityQueue;

class Heap {
  private PriorityQueue<Integer> heap;
  
  public Heap() {
    heap = new PriorityQueue<Integer>();
  }

  public void offer(int value) {
    heap.offer(value);
  }

  public int poll() {
    return heap.poll();
  }
  
  public int peek() {
    return heap.peek();
  }
  
  public boolean isEmpty() {
    return heap.isEmpty();
  }
}

// 使用示例
Heap heap = new Heap();
heap.offer(3);
heap.offer(1);
heap.offer(2);
System.out.println(heap.poll()); // 输出1
System.out.println(heap.peek()); // 输出2
System.out.println(heap.isEmpty()); // 输出false

4. 树：

树是一种非线性的数据结构，它具有层次结构。在Java中，可以使用节点类表示树，并使用递归实现树的相关算法。

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

class Tree {
  private TreeNode root;
  
  public Tree() {
    root = null;
  }
  
  public void insert(int value) {
    root = insert(root, value);
  }
  
  private TreeNode insert(TreeNode node, int value) {
    if (node == null) {
      node = new TreeNode(value);
    } else {
      if (value < node.value) {
        node.left = insert(node.left, value);
      } else {
        node.right = insert(node.right, value);
      }
    }
    return node;
  }
  
  public boolean search(int value) {
    return search(root, value);
  }
  
  private boolean search(TreeNode node, int value) {
    if (node == null) {
      return false;
    }
    if (node.value == value) {
      return true;
    }
    if (value < node.value) {
      return search(node.left, value);
    } else {
      return search(node.right, value);
    }
  }
}

// 使用示例
Tree tree = new Tree();
tree.insert(2);
tree.insert(1);
tree.insert(3);
System.out.println(tree.search(2)); // 输出true
System.out.println(tree.search(4)); // 输出false

以上是使用Java实现栈、队列、堆和树的经典算法的示例代码，可以根据实际需求进行扩展和优化。