update stack and queue.

codes/cpp/chapter_stack_and_queue/array_queue.cpp

@@ -9,26 +9,27 @@
 /* 基于环形数组实现的队列 */
 class ArrayQueue {
 private:
-    vector<int> nums; // 用于存储队列元素的数组
-    int front = 0;    // 头指针，指向队首
-    int rear = 0;     // 尾指针，指向队尾 + 1
+    int *nums;      // 用于存储队列元素的数组
+    int cap;        // 队列容量
+    int front = 0;  // 头指针，指向队首
+    int rear = 0;   // 尾指针，指向队尾 + 1
 
 public:
     ArrayQueue(int capacity) {
         // 初始化数组
-        nums.resize(capacity);
+        cap = capacity;
+        nums = new int[capacity];
     }
 
     /* 获取队列的容量 */
     int capacity() {
-        return nums.size();
+        return cap;
     }
 
     /* 获取队列的长度 */
     int size() {
-        int cap = capacity();
         // 由于将数组看作为环形，可能 rear < front ，因此需要取余数
-        return (cap + rear - front) % cap;
+        return (capacity() + rear - front) % capacity();
     }
 
     /* 判断队列是否为空 */
@@ -67,6 +68,14 @@ public:
         return nums[front];
     }
 
+    /* 访问指定索引元素 */
+    int get(int index) {
+        if (index >= size())
+            throw out_of_range("索引越界");
+        return nums[(front + index) % capacity()];
+    }
+
+    /* 将数组转化为 Vector 并返回 */
     vector<int> toVector() {
         int siz = size();
         int cap = capacity();
@@ -99,6 +108,10 @@ int main() {
     int peek = queue->peek();
     cout << "队首元素 peek = " << peek << endl;
 
+    /* 访问指定索引元素 */
+    int num = queue->get(2);
+    cout << "队列第 3 个元素为 num = " << num << endl;
+
     /* 元素出队 */
     int poll = queue->poll();
     cout << "出队元素 poll = " << poll << "，出队后 queue = ";

codes/cpp/chapter_stack_and_queue/array_stack.cpp

@@ -69,6 +69,10 @@ int main() {
     int top = stack->top();
     cout << "栈顶元素 top = " << top << endl;
 
+    /* 访问索引 index 处元素 */
+    int num = stack->get(3);
+    cout << "栈索引 3 处的元素为 num = " << num << endl;
+
     /* 元素出栈 */
     int pop = stack->pop();
     cout << "出栈元素 pop = " << pop << "，出栈后 stack = ";

codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp

@@ -9,60 +9,68 @@
 /* 基于链表实现的队列 */
 class LinkedListQueue {
 private:
-    ListNode *front, *back;
-    int qSize;
+    ListNode *front, *rear;  // 头结点 front ，尾结点 rear 
+    int queSize;
 
 public:
     LinkedListQueue() {
         front = nullptr;
-        back = nullptr;
-        qSize = 0;
+        rear = nullptr;
+        queSize = 0;
     }
 
     /* 获取队列的长度 */
     int size() {
-        return qSize;
+        return queSize;
     }
 
     /* 判断队列是否为空 */
     bool empty() {
-        return qSize == 0;
+        return queSize == 0;
     }
 
     /* 入队 */
     void offer(int num) {
         // 尾结点后添加 num
         ListNode* node = new ListNode(num);
-        node->next = back;
-        back = node;
-        qSize++;
+        // 如果队列为空，则令头、尾结点都指向该结点
+        if (front == nullptr) {
+            front = node;
+            rear = node;
+        }
+        // 如果队列不为空，则将该结点添加到尾结点后
+        else {
+            rear->next = node;
+            rear = node;
+        }
+        queSize++;
     }
 
     /* 出队 */
     int poll() {
-        if (qSize == 0)
-            throw out_of_range("队列为空");
+        int num = peek();
         // 删除头结点
-        ListNode* node = front;
         front = front->next;
-        return node->val;
+        queSize--;
+        return num;
     }
 
     /* 访问队首元素 */
     int peek() {
+        if (size() == 0)
+            throw out_of_range("队列为空");
         return front->val;
     }
 
-    /* 将 List 转化为 Array 并返回 */
+    /* 将链表转化为 Vector 并返回 */
     vector<int> toVector() {
         ListNode* node = front;
-        vector<int> vec;
-        while (node != nullptr) {
-            vec.push_back(node->val);
+        vector<int> res(size());
+        for (int i = 0; i < res.size(); i++) {
+            res[i] = node->val;
             node = node->next;
         }
-        reverse(vec.begin(), vec.end());
-        return vec;
+        return res;
     }
 };
 

codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp

@@ -10,17 +10,17 @@
 class LinkedListStack {
 private:
     ListNode* stackTop; // 将头结点作为栈顶
-    int stackSize;      // 栈的长度
+    int stkSize;      // 栈的长度
 
 public:
     LinkedListStack() {
         stackTop = nullptr;
-        stackSize = 0;
+        stkSize = 0;
     }
 
     /* 获取栈的长度 */
     int size() {
-        return stackSize;
+        return stkSize;
     }
 
     /* 判断栈是否为空 */
@@ -33,16 +33,14 @@ public:
         ListNode* node = new ListNode(num);
         node->next = stackTop;
         stackTop = node;
-        stackSize++;
+        stkSize++;
     }
 
     /* 出栈 */
     int pop() {
-        if (size() == 0)
-            throw out_of_range("栈为空");
-        int num = stackTop->val;
+        int num = top();
         stackTop = stackTop->next;
-        stackSize--;
+        stkSize--;
         return num;
     }
 

codes/java/chapter_stack_and_queue/array_queue.java

@@ -67,15 +67,23 @@ class ArrayQueue {
         return nums[front];
     }
 
+    /* 访问索引 index 处元素 */
+    int get(int index) {
+        if (index >= size())
+            throw new IndexOutOfBoundsException();
+        return nums[(front + index) % capacity()];
+    }
+
+    /* 返回数组 */
     public int[] toArray() {
         int size = size();
         int capacity = capacity();
         // 仅转换有效长度范围内的列表元素
-        int[] arr = new int[size];
+        int[] res = new int[size];
         for (int i = 0, j = front; i < size; i++, j++) {
-            arr[i] = nums[j % capacity];
+            res[i] = nums[j % capacity];
         }
-        return arr;
+        return res;
     }
 }
 

codes/java/chapter_stack_and_queue/array_stack.java

@@ -69,6 +69,10 @@ public class array_stack {
         int peek = stack.peek();
         System.out.println("栈顶元素 peek = " + peek);
 
+        /* 访问索引 index 处元素 */
+        int num = stack.get(3);
+        System.out.println("栈索引 3 处的元素为 num = " + num);
+
         /* 元素出栈 */
         int pop = stack.pop();
         System.out.println("出栈元素 pop = " + pop + "，出栈后 stack = " + Arrays.toString(stack.toArray()));

codes/java/chapter_stack_and_queue/linkedlist_queue.java

@@ -7,46 +7,69 @@
 package chapter_stack_and_queue;
 
 import java.util.*;
+import include.*;
 
 /* 基于链表实现的队列 */
 class LinkedListQueue {
-    LinkedList<Integer> list;
+    private ListNode front, rear;  // 头结点 front ，尾结点 rear 
+    private int queSize = 0;
 
     public LinkedListQueue() {
-        // 初始化链表
-        list = new LinkedList<>();
+        front = null;
+        rear = null;
     }
 
     /* 获取队列的长度 */
     public int size() {
-        return list.size();
+        return queSize;
     }
 
     /* 判断队列是否为空 */
     public boolean isEmpty() {
-        return list.size() == 0;
+        return size() == 0;
     }
 
     /* 入队 */
     public void offer(int num) {
         // 尾结点后添加 num
-        list.addLast(num);
+        ListNode node = new ListNode(num);
+        // 如果队列为空，则令头、尾结点都指向该结点
+        if (front == null) {
+            front = node;
+            rear = node;
+        // 如果队列不为空，则将该结点添加到尾结点后
+        } else {
+            rear.next = node;
+            rear = node;
+        }
+        queSize++;
     }
 
     /* 出队 */
     public int poll() {
+        int num = peek();
         // 删除头结点
-        return list.removeFirst();
+        front = front.next;
+        queSize--;
+        return num;
     }
 
     /* 访问队首元素 */
     public int peek() {
-        return list.getFirst();
+        if (size() == 0)
+            throw new IndexOutOfBoundsException();
+        return front.val;
     }
 
-    /* 将 List 转化为 Array 并返回 */
-    public Object[] toArray() {
-        return list.toArray();
+    /* 将链表转化为 Array 并返回 */
+    public int[] toArray() {
+        ListNode node = front;
+        int[] res = new int[size()];
+        for (int i = 0; i < res.length; i++) {
+            res[i] = node.val;
+            node = node.next;
+        }
+        return res;
     }
 }
 

codes/java/chapter_stack_and_queue/linkedlist_stack.java

@@ -12,7 +12,7 @@ import include.*;
 /* 基于链表实现的栈 */
 class LinkedListStack {
     private ListNode stackPeek;  // 将头结点作为栈顶
-    private int stackSize = 0;   // 栈的长度
+    private int stkSize = 0;   // 栈的长度
     
     public LinkedListStack() {
         stackPeek = null;
@@ -20,7 +20,7 @@ class LinkedListStack {
 
     /* 获取栈的长度 */
     public int size() {
-        return stackSize;
+        return stkSize;
     }
 
     /* 判断栈是否为空 */
@@ -33,16 +33,14 @@ class LinkedListStack {
         ListNode node = new ListNode(num);
         node.next = stackPeek;
         stackPeek = node;
-        stackSize++;
+        stkSize++;
     }
 
     /* 出栈 */
     public int pop() {
-        if (size() == 0)
-            throw new IndexOutOfBoundsException();
         int num = peek();
         stackPeek = stackPeek.next;
-        stackSize--;
+        stkSize--;
         return num;
     }
 

codes/python/chapter_stack_and_queue/array_stack.py

@@ -59,6 +59,10 @@ if __name__ == "__main__":
     peek = stack.peek()
     print("栈顶元素 peek =", peek)
 
+    """ 访问索引 index 处元素 """
+    num = stack.get(3);
+    print("栈索引 3 处的元素为 num =", num);
+
     """ 元素出栈 """
     pop = stack.pop()
     print("出栈元素 pop =", pop)

codes/python/chapter_stack_and_queue/linkedlist_stack.py

@@ -31,12 +31,10 @@ class LinkedListStack:
 
     """ 出栈 """
     def pop(self):
-        # 判空处理
-        if not self.__peek: return None
-        pop = self.__peek.val
+        num = self.peek()
         self.__peek = self.__peek.next
         self.__size -= 1
-        return pop
+        return num
 
     """ 访问栈顶元素 """
     def peek(self):