在Java面试中，除了对基础知识的问答外，还经常会涉及手写数据结构的问题。本文将介绍一些在Java面试中常见的手写数据结构，包括链表、栈、队列和二叉树，并提供简单示例代码，帮助您准备面试时更好地理解和实现这些数据结构。

链表（Linked List）

 链表是一种基本的数据结构，由节点组成，每个节点包含一个数据元素和指向下一个节点的引用。在面试中，常常要求手写链表的实现，包括添加节点、删除节点和反转链表等操作。以下是链表的简单示例代码：

class Node {
    int data;
    Node next;

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

class LinkedList {
    Node head;

    // 添加节点
    public void addNode(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 deleteNode(int data) {
        if (head == null) {
            return;
        }
        if (head.data == data) {
            head = head.next;
            return;
        }
        Node current = head;
        Node prev = null;
        while (current != null && current.data != data) {
            prev = current;
            current = current.next;
        }
        if (current != null) {
            prev.next = current.next;
        }
    }

    // 反转链表
    public void reverse() {
        Node prev = null;
        Node current = head;
        Node next = null;
        while (current != null) {
            next = current.next;
            current.next = prev;
            prev = current;
            current = next;
        }
        head = prev;
    }
}

栈（Stack）

栈是一种后进先出（LIFO）的数据结构，只允许在栈顶进行插入和删除操作。面试中常要求手写栈的实现，包括入栈、出栈和获取栈顶元素等操作。以下是栈的简单示例代码：

class Stack {
    private int maxSize;
    private int top;
    private int[] stackArray;

    public Stack(int size) {
        maxSize = size;
        stackArray = new int[maxSize];
        top = -1;
    }

    // 入栈
    public void push(int value) {
        if (top < maxSize - 1) {
            stackArray[++top] = value;
        }
    }

    // 出栈
    public int pop() {
        if (top >= 0) {
            return stackArray[top--];
        }
        return -1;
    }

    // 获取栈顶元素
    public int peek() {
        if (top >= 0) {
            return stackArray[top];
        }
        return -1;
    }

    // 判断栈是否为空
    public boolean isEmpty() {
        return (top == -1);
    }
}

队列（Queue）

队列是一种先进先出（FIFO）的数据结构，可以在队尾插入元素，在队头删除元素。面试中可能要求手写队列的实现，包括入队、出队和获取队头元素等操作。以下是队列的简单示例代码：

class Queue {
    private int maxSize;
    private int front;
    private int rear;
    private int[] queueArray;

    public Queue(int size) {
        maxSize = size;
        queueArray = new int[maxSize];
        front = 0;
        rear = -1;
    }

    // 入队
    public void enqueue(int value) {
        if (rear < maxSize - 1) {
            queueArray[++rear] = value;
        }
    }

    // 出队
    public int dequeue() {
        if (front <= rear) {
            return queueArray[front++];
        }
        return -1;
    }

    // 获取队头元素
    public int peek() {
        if (front <= rear) {
            return queueArray[front];
        }
        return -1;
    }

    // 判断队列是否为空
    public boolean isEmpty() {
        return (front > rear);
    }
}

二叉树（Binary Tree）

二叉树是一种每个节点最多有两个子节点的树形数据结构。面试中可能要求手写二叉树的实现，包括插入节点、查找节点和遍历等操作。以下是二叉树的简单示例代码：

class Node {
    int key;
    Node left;
    Node right;

    public Node(int value) {
        key = value;
        left = null;
        right = null;
    }
}

class BinaryTree {
    Node root;

    // 插入节点
    public void insert(int value) {
        root = insertNode(root, value);
    }

    private Node insertNode(Node root, int value) {
        if (root == null) {
            root = new Node(value);
            return root;
        }
        if (value < root.key) {
            root.left = insertNode(root.left, value);
        } else if (value > root.key) {
            root.right = insertNode(root.right, value);
        }
        return root;
    }

    // 查找节点
    public boolean search(int value) {
        return searchNode(root, value);
    }

    private boolean searchNode(Node root, int value) {
        if (root == null || root.key == value) {
            return root != null;
        }
        if (value < root.key) {
            return searchNode(root.left, value);
        } else {
            return searchNode(root.right, value);
        }
    }

    // 中序遍历
    public void inorderTraversal() {
        inorder(root);
    }

    private void inorder(Node root) {
        if (root != null) {
            inorder(root.left);
            System.out.print(root.key + " ");
            inorder(root.right);
        }
    }
}

在面试准备过程中，熟悉并掌握这些常见的手写数据结构的实现是很重要的。理解它们的原理和实现方式，能够帮助您在面试中更好地回答问题，展示出扎实的编程基础和问题解决能力。

总结

 在Java面试中，常常会要求手写一些基本的数据结构。链表、栈、队列和二叉树是常见的手写数据结构。通过理解它们的原理和实现方式，并进行实践编码，可以在面试中更好地应对与数据结构相关的问题。掌握这些数据结构的实现将有助于提高您的编程能力和问题解决能力，使您在面试中脱颖而出。

  学java，就到java编程狮！