数据结构挑战：Java实现链表、栈和队列

原创ゞ浴缸里的玫瑰 2024-12-08 05:54 5阅读 0赞

在Java中，我们可以使用类来定义数据结构。以下是针对链表、栈和队列的实现：

1. 链表（Linked List）

```java
// Node class
class Node {
    int data;
    Node next;

// Constructor
    Node(int d) {
        data = d;
        next = null;
    }
}

// LinkedList class
class LinkedList {
    Node head;

// Constructor
    LinkedList() {
        head = null;
    }

// Add a new node to the end of the list
    void appendNode(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;
        }
    }

// Display the list
    void displayList() {
        Node currentNode = head;

while (currentNode != null) {
            System.out.print(currentNode.data + " -> ");
            currentNode = currentNode.next;
        }
        System.out.println("NULL");
    }
}
```

2. 栈（Stack）

```java
// Stack class using Array
class Stack {
    int[] stackArray; // Array for storing elements
    int topIndex; // Index of the top element

// Constructor
    Stack(int capacity) {
        stackArray = new int[capacity];
        topIndex = -1;
    }

// Push a new element to the top of the stack
    void push(int data) {
        if (topIndex == stackArray.length - 1) {
            System.out.println("Stack is full. Can't push " + data);
        } else {
            stackArray[++topIndex] = data;
        }
    }

// Pop an element from the top of the stack
    int pop() {
        if (topIndex == -1) {
            System.out.println("Stack is empty. Can't pop");
            return -1;
        } else {
            int poppedData = stackArray[topIndex--];
            return poppedData;
        }
    }

// Display the elements in the stack
    void displayStack() {
        if (topIndex == -1) {
            System.out.println("Stack is empty");
            return;
        }

Node currentNode = stackArray[topIndex];

while (currentNode != null) {
            System.out.print(currentNode.data + " -> ");
            currentNode = currentNode.next;
        }
        System.out.println("NULL");
    }
}
```

3. 队列（Queue）

队列通常使用双端队列（Deque）实现，Java中`java.util.Deque`是一个接口，提供了插入和删除元素的方法。

以下是实现一个基于数组的双端队列的代码：

```java
// Queue class using Array
class Queue {
    int[] queueArray; // Array for storing elements
    int frontIndex, rearIndex; // Indexes of the front and rear elements

// Constructor
    Queue(int capacity) {
        queueArray = new int[capacity];
        frontIndex = -1;
        rearIndex = -1;
    }

// Enqueue a new element to the end of the queue
    void enqueue(int data) {
        if (frontIndex == queueArray.length - 1) {
            System.out.println("Queue is full. Can't enqueue " + data);
        } else {
            rearIndex++;
            queueArray[rearIndex] = data;
        }
    }

// Dequeue an element from the front of the queue
    int dequeue() {
        if (frontIndex == -1) {
            System.out.println("Queue is empty. Can't dequeue");
            return -1;
        } else {
            int dequeuedData = queueArray[frontIndex++];
            if (frontIndex > rearIndex) { // Reversing the queue
                frontIndex--;
                rearIndex++;
                for (int i = rearIndex; i >= frontIndex; i--) { // Swapping elements
                    int tempData = queueArray[i];
                    queueArray[i] = queueArray[frontIndex + i - rearIndex]];
                    queueArray[frontIndex + i - rearIndex]] = tempData;
                }
            }
            return dequeuedData;
        }
    }

// Display the elements in the queue
    void displayQueue() {
        if (frontIndex == -1) {
            System.out.println("Queue is empty");
            return;
        }

Node currentNode = queueArray[frontIndex]];

while (currentNode != null) {
            System.out.print(currentNode.data + " -> ");
            currentNode = currentNode.next;
        }
        System.out.println("NULL");
    }
}
```

以上代码实现了链表、栈和队列的基本数据结构。你可以根据需要使用这些类。