Stacks and queues are easier to understand in data structure and algorithm learning. But sometimes I feel that I have mastered the stack and the queue, but when I encounter different situations when I write, I will not deal with it, so I still want to review it again.

Stack:
is a linear table with one end limited and one end allowed to operate. That is: first take the first take, then put the first take. It is what we usually call "advanced out" (FILO). There are two most common storage structures: one is sequential storage and the other is chained storage. The sequential storage is the array that was said before, and the chain storage is the linked list.

queue:
Like a stack, a queue is also a linear table whose characteristics are “first in, first out” (FIFO), inserted at one end and deleted at the other end. Just like queuing, the person who just came in is going to be at the end of the team. Every time the pop is the leader of the team.

The specific usage scenarios are still quite a few such as: hex conversion, infix and suffix expressions, maze solution, text editor, binary tree traversal, etc., the solution needs to use the idea of ​​stack and queue. Let's write the implementation of the stack and queue.

/**
   * Determine if the stack is empty
 */
template<class E>
bool Stack<E>::isEmpty() {
    return top == -1;
}

/**
   * Top element bomb stack
 */
template<class E>
E Stack<E>::pop() {
    assert(top >= 0);
    return array[top--];
}

/**
   * Get the top element of the stack
 */
template<class E>
E Stack<E>::peek() {
    assert(top >= 0);
    return array[top];
}

/**
   * Element stack
 */
template<class E>
void Stack<E>::push(E e) {
    if (top + 1 == size) {
        growArray();
    }
    array[++top] = e;
}

/**
   * Expansion array
 */
template<class E>
void Stack<E>::growArray() {
    size += size >> 1;
    array = (E *) realloc(array, size * sizeof(E));
}

Using arrays to implement a stack is pretty straightforward. If you use arrays to implement a queue? The queue is FIFO, so we need to remove the first element each time we queue, because the storage structure is an array, the following elements need to be anteriorly traversed, the time complexity is O(n). At this time, we might as well think that there is no way to convert the time complexity to O(1) level without using the logic element. the answer is:Bidirectional array。

template<class E>
ArrayQueue<E>::ArrayQueue(int size) {
    / / Make sure the length of the array is a power of 2
    int init_size = 8;
    if (size >= init_size) {
        init_size = size;
        init_size |= init_size >> 1;
        init_size |= init_size >> 2;
        init_size |= init_size >> 4;
        init_size |= init_size >> 8;
        init_size |= init_size >> 16;
        init_size += 1;
    }
    array = (E *) malloc(sizeof(E) * init_size);
    this->size = init_size;
}

template<class E>
void ArrayQueue<E>::push(E e) {
    head = (head - 1) & (size - 1);
    array[head] = e;
    if (head == tail) {
        growArray();
    }
}

template<class E>
E ArrayQueue<E>::pop() {
    tail = (tail - 1) & (size - 1);
    return array[tail];
}

template<class E>
E ArrayQueue<E>::peek() {
    return array[(tail - 1) & (size - 1)];
}

template<class E>
bool ArrayQueue<E>::isEmpty() {
    return tail == head;
}

template<class E>
ArrayQueue<E>::~ArrayQueue() {
    delete[] array;
}
/**
 * Open up new arrays and adjust element order
**/
template<class E>
void ArrayQueue<E>::growArray() {
    int new_size = size << 1;
    E *new_array = (E *) malloc(new_size * sizeof(E));

         // Align the elements behind the array to the front
    int r = size - tail;
    copyArrayElement(array, head, new_array, 0, r);
         // Align the elements in front of the array to the back
    copyArrayElement(array, 0, new_array, r, head);
         // release the memory
    free(array);
    array = new_array;
         // Change the pointer again
    head = 0;
    tail = size;
    size = new_size;
}

Video link:
Video password: bmmt