栈与队列

栈

定义

栈是一种操作受限的线性表，只支持在栈顶入栈（push）和出栈（pop）操作，有后进先出的特性。可用数组或链表实现。

时间复杂度

入栈：O(1)
出栈：O(1)

---

队列

定义

队列是一种操作受限的线性表，只支持在队头出队（dequeue）、队尾入队（enqueue）操作，有先进先出的特性。可用数组或链表实现。

时间复杂度

入队：O(1)
出队：O(1)

各种队列介绍

1. 循环队列
   长的像个环，比如插入操作，当前状态：n=8，head=3，tail=7。插入新元素后，tail后移，变为0。
   在实现上和非循环队列相比如下：

   类型	队空	队满
   非循环队列	head==tail	tail==n
   循环队列	head==tail	(tail+1)%n==head

   实现：

/**
 * 循环队列
 * Class CircularQueue
 */
class CircularQueue
{
    private $items = [];
    private $n = 0;
    private $head = 0;
    private $tail = 0;

    public function __construct($n)
    {
        $this->n = $n;
    }

    /**
     * 入队
     * @param $v
     * @return bool
     */
    public function enqueue($v)
    {
        // 队列满了
        if (($this->tail + 1) % $this->n == $this->head) {
            return false;
        }

        $this->items[$this->tail] = $v;
        $this->tail = ($this->tail + 1) % $this->n;
        return true;
    }

    /**
     * 出队
     * @return mixed|null
     */
    public function dequeue()
    {
        // 队列空了
        if ($this->head == $this->tail) {
            return null;
        }

        $v = $this->items[$this->head];
        $this->head = ($this->head + 1) % $this->n;
        return $v;
    }
}

2. 阻塞队列
   入队、出队操作可以阻塞。

   队列为空时，从队头取数据会被阻塞，直到队列中有数据了才返回；
   队列已满，插入数据会被阻塞，直到队列中有空闲位置后再插入数据，再返回。

3. 并发队列
   队列的操作多线程安全。

   最简单的实现方法就是在入队、出队的方法上加锁，同一时刻仅允许一个存或取操作，但是这样锁的粒度大，并发度比较低。

   基于数组的循环队列（避免数据搬移），利用 CAS（Compare And Swap 避免真正的去OS底层申请锁资源）原子操作，可实现高效的无锁并发队列。

---

算法编程

1. 请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）。

   • 思路：第一个栈接收push数据，需要pop时，把所有数据依次弹出到第二个栈，这样第二个栈里的元素就是倒序的了，只要第二个栈不空，则可对第二个栈进行pop、peek操作，如果第二个栈为空，则再将第一个栈的数据依次弹出到第二个栈。判空则是两个栈都为空才为空。

   答：

class MyQueue {

    private $s1;
    private $s2;

    /**
     * Initialize your data structure here.
     */
    function __construct() {
        $this->s1 = [];
        $this->s2 = [];
    }

    /**
     * Push element x to the back of queue.
     * @param Integer $x
     * @return NULL
     */
    function push($x) {
        array_push($this->s1, $x);
    }

    /**
     * Removes the element from in front of queue and returns that element.
     * @return Integer
     */
    function pop() {
        if (!empty($this->s2)) {
            return array_pop($this->s2);
        }
        while (!empty($this->s1)) {
            $x = array_pop($this->s1);
            array_push($this->s2, $x);
        }
        return array_pop($this->s2);
    }

    /**
     * Get the front element.
     * @return Integer
     */
    function peek() {
        if (!empty($this->s2)) {
            return end($this->s2);
        }
        while (!empty($this->s1)) {
            $x = array_pop($this->s1);
            array_push($this->s2, $x);
        }
        return end($this->s2);
    }

    /**
     * Returns whether the queue is empty.
     * @return Boolean
     */
    function empty() {
        return empty($this->s1) && empty($this->s2);
    }
}

2. 请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

   • 思路：push数据时，push到不为空的那个队列，pop时将不为空的队列数据依次弹出到另一个为空的队列，直到不为空的队列数据剩下一个，然后弹出即可。

   答：

class MyStack {

    private $q1;
    private $q2;

    /**
     * Initialize your data structure here.
     */
    function __construct() {
        $this->q1 = [];
        $this->q2 = [];
    }

    /**
     * Push element x onto stack.
     * @param Integer $x
     * @return NULL
     */
    function push($x) {
        if (empty($this->q1)) {
            array_unshift($this->q2, $x);
        } else {
            array_unshift($this->q1, $x);
        }
    }

    /**
     * Removes the element on top of the stack and returns that element.
     * @return Integer
     */
    function pop() {
        if (empty($this->q2)) {
            while (count($this->q1) > 1) {
                $x = array_pop($this->q1);
                array_unshift($this->q2, $x);
            }
            return array_pop($this->q1);
        }
        if (empty($this->q1)) {
            while (count($this->q2) > 1) {
                $x = array_pop($this->q2);
                array_unshift($this->q1, $x);
            }
            return array_pop($this->q2);
        }
    }

    /**
     * Get the top element.
     * @return Integer
     */
    function top() {
        if (empty($this->q2)) {
            while (count($this->q1) > 0) {
                if (count($this->q1) == 1) {
                    $top = $this->q1[0];
                }
                $x = array_pop($this->q1);
                array_unshift($this->q2, $x);
            }
            return $top;
        }
        if (empty($this->q1)) {
            while (count($this->q2) > 0) {
                if (count($this->q2) == 1) {
                    $top = $this->q2[0];
                }
                $x = array_pop($this->q2);
                array_unshift($this->q1, $x);
            }
            return $top;
        }
    }

    /**
     * Returns whether the stack is empty.
     * @return Boolean
     */
    function empty() {
        return empty($this->q1) && empty($this->q2);
    }
}

3. 给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。返回滑动窗口中的最大值。
   答：

class Solution {

    /**
     * @param Integer[] $nums
     * @param Integer $k
     * @return Integer[]
     */
    function maxSlidingWindow($nums, $k) {
        if (empty($nums) || count($nums) < 2 || $k == 0) {
            return $nums;
        }
        $window = new spldoublylinkedlist();
        $res = [];
        
        foreach ($nums as $i => $v) {
            while (!$window->isEmpty() && $nums[$window->top()] <= $v) {
                $window->pop();
            }
            $window->push($i);
            if ($window->bottom() <= $i - $k) {
                $window->shift();
            }
            if ($i >= $k - 1) {
                $res[] = $nums[$window->bottom()];
            }
        }
        return $res;
    }
}

4. 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
   有效字符串需满足：
   1. 左括号必须用相同类型的右括号闭合。
   2. 左括号必须以正确的顺序闭合。

class Solution {

    /**
     * @param String $s
     * @return Boolean
     */
    function isValid($s) {
        $stack = [];
        $map = [')' => '(', ']' => '[', '}' => '{'];

        $i = 0;
        while (!empty($s[$i])) {
            if (in_array($s[$i], $map)) {
                array_push($stack, $s[$i]);
            } else if (array_pop($stack) != $map[$s[$i]]) {
                return false;
            }
            $i++;
        }

        return empty($stack);
    }
}