PHP 中队列和堆栈对比

DS 扩展包路径：[DS扩展包路径]: https://pecl.php.net/package/ds

CentOS7 中 DS 扩展安装（使用 phpize）

> phpize
> ./configure --with-php-config=/php/bin/php-config
> make && make install

DS 扩展函数介绍

简介：DS 扩展是 PHP7 高效的数据结构，可以作为 array 的替代.

堆栈：堆栈是后进先出(last in, first out)或后进先出(LIFO)集合，它只允许访问结构顶部的值，并按该顺序进行迭代。

<?php
    //PHP 中的堆栈实现，PHP 的 DS 扩展中集成了堆栈的操作函数，DS 扩展是需要单独安装的
    //DS 中堆栈的所有方法
    Ds\Stack implements Ds\Collection , ArrayAccess {
        /* 方法 */
        public allocate ( int $capacity ) : void
        public capacity ( ) : int
        public clear ( ) : void
        public copy ( ) : Ds\Stack
        public isEmpty ( ) : bool
        public peek ( ) : mixed
        public pop ( ) : mixed
        public push ( mixed ...$values ) : void
        public toArray ( ) : array
    }
    
    $list = [11,12,13];
    //初始化一个堆栈并将输入入栈，入栈顺序是
    $stack = new \Ds\Stack($list);
    //设置栈的内存大小，如果该值小于或等于当前容量，容量将保持不变。
    $stack->allocate(16);
    //查看堆栈
    print_r($stack);
    /*
    输出内容
    Ds\Stack Object ( 
        [0] => 13 
        [1] => 12 
        [2] => 11 
    )
    */
    //获取当前容量大小，如果入栈数据大小实际容量大于 allocate() 设置容量将返回实际容量；如果实际容量小于 allocate() 设置的容量将返回设置的容量；上面设置16将返回16；如果不设置则返回8
    print_r($stack->capacity());
    //清空堆栈
    print_r($stack->clear());
    /*
    输出内容
    Ds\Stack Object ()
    */
    //堆栈转数组
    print_r($stack->toArray());
    /*
    输出数组：
    Array ( 
        [0] => 13 
        [1] => 12 
        [2] => 11 
    )
    */
    //push 方法参数格式
    $stack->push(14);
    $stack->push(14,15);
    $stack->push([14,15]);


    $list = [11,12,13];
    $stack = new \Ds\Stack($list);
    print_r($stack->count());//获取堆栈总数 输出：3

堆栈复制并修改堆栈变化对比

<?php
    $list = [11,12,13];
    $stack = new \Ds\Stack($list);
    print_r($stack);
    /*
    初始化堆栈输出内容：
    Ds\Stack Object ( 
        [0] => 13 
        [1] => 12 
        [2] => 11 
    )
    */
    $stack_copy = $stack->copy();
    print_r($stack_copy);
    /*
    复制副本输出内容：
    Ds\Stack Object ( 
        [0] => 13 
        [1] => 12 
        [2] => 11 
    )
    */
    //原堆栈入栈数据
    $stack->push(14);
    /*
    原堆栈输出数据：
    Ds\Stack Object ( 
        [0] => 14 
        [1] => 13 
        [2] => 12 
        [3] => 11 
    )
    复制副本堆栈输出数据：
    Ds\Stack Object ( 
        [0] => 13 
        [1] => 12 
        [2] => 11 
    )
    */
    //复制副本堆栈入栈数据
    $stack->push(15);
    /*
    原堆栈输出数据：
    Ds\Stack Object ( 
        [0] => 14 
        [1] => 13 
        [2] => 12 
        [3] => 11 
    )
    复制副本堆栈输出数据：
    Ds\Stack Object ( 
        [0] => 15 
        [1] => 13 
        [2] => 12 
        [3] => 11 
    )
    */

堆栈是否为空对比

<?php
    $list = [11,12,13];
    $stack = new \Ds\Stack($list);
    $stack1 = new \Ds\Stack();
    var_dump($stack->isEmpty());//输出：bool(false)
    var_dump($stack1->isEmpty());//输出：bool(true)
    //清空 stack
    $stack->clear();
    //入栈 stack1
    $stack1->push(14);
    var_dump($stack->isEmpty());//输出：bool(true)
    var_dump($stack1->isEmpty());//输出：bool(false)

数据出栈对比

<?php
    $list = [11,12,13];
    $stack = new \Ds\Stack($list);
    print_r($stack);
    /*
    初始化数输出数据：
    Ds\Stack Object ( 
        [0] => 13 
        [1] => 12 
        [2] => 11 
    )
    */
    //方法 peek 只返回栈顶数据，不出栈
    print_r($stack->peek());//输出：13
    print_r($stack);
    /*
    调用 peek 后输出数据：
    Ds\Stack Object ( 
        [0] => 13 
        [1] => 12 
        [2] => 11 
    )
    */
    //方法 pop 返回栈顶数据并出栈
    print_r($stack->pop());//输出：13
    print_r($stack);
    /*
    调用 pop 后输出数据：
    Ds\Stack Object ( 
        [0] => 12 
        [1] => 11
    )
    */

队列：队列是一个先入先出或FIFO集合，它只允许访问队列前面的值，并按该顺序进行迭代。

<?php
    Ds\Queue implements Ds\Collection , ArrayAccess {
        /* Constants */
        const int MIN_CAPACITY = 8 ;
        /* 方法 */
        public allocate ( int $capacity ) : void
        public capacity ( ) : int
        public clear ( ) : void
        public copy ( ) : Ds\Queue
        public isEmpty ( ) : bool
        public peek ( ) : mixed
        public pop ( ) : mixed
        public push ( mixed ...$values ) : void
        public toArray ( ) : array
    }

    $list = [11,12,13];
    //初始化队列
    $queue = new \Ds\Queue($list);
    $queue->capacity();//返回当前容量：8
    //设置队列内存大小
    $queue->allocate(31);
    $queue->capacity();//返回设置后的当前容量：32
    //设置队列内存大小
    $queue->allocate(33);
    $queue->capacity();//返回设置后的当前容量：64
    //capacity 容量总是四舍五入到最接近的2次方。

    print_r($queue->count());//获取队列长度 输出：3

队列清空、判断空对比

<?php
    $list = [11,12,13];
    //初始化队列
    $queue = new \Ds\Queue($list);
    $queue1 = new \Ds\Queue();
    var_dump($queue->isEmpty());//输出：bool(false)
    var_dump($queue1->isEmpty());//输出：bool(true)
    $queue->clear();
    $queue1->push(14);
    var_dump($queue->isEmpty());//输出：bool(true)
    var_dump($queue1->isEmpty());//输出：bool(false)

队列复制并修改堆栈变化对比

<?php
    $list = [11,12,13];
    //初始化队列
    $queue = new \Ds\Queue($list);
    $queue_copy = $queue->copy();
    print_r($queue);
    /*
    初始化输出队列：
    Ds\Queue Object ( 
        [0] => 11 
        [1] => 12 
        [2] => 13 
    )
    */
    print_r($queue_copy);
    /*
    复制副本输出队列：
    Ds\Queue Object ( 
        [0] => 11 
        [1] => 12 
        [2] => 13 
    )
    */
    //原队列入队数据
    $queue->push(14);
    /*
    原队列输出队列：
    Ds\Queue Object ( 
        [0] => 11 
        [1] => 12 
        [2] => 13 
        [3] => 14 
    )
    复制副本输出队列：
    Ds\Queue Object ( 
        [0] => 11 
        [1] => 12 
        [2] => 13 
    )
    */
    //复制副本队列入队数据
    $queue_copy->push(15);
    /*
    原队列输出队列：
    Ds\Queue Object ( 
        [0] => 11 
        [1] => 12 
        [2] => 13 
    )
    复制副本输出队列：
    Ds\Queue Object ( 
        [0] => 11 
        [1] => 12 
        [2] => 13 
        [3] => 15 
    )
    */

队列出队数据对比

<?php
    $list = [11,12,13];
    //初始化队列
    $queue = new \Ds\Queue($list);
    //方法 peek 只返回队头数据，不出队列
    print_r($queue->peek());//输出：11
    print_r($queue);
    /*
    原队列输出队列：
    Ds\Queue Object ( 
        [0] => 11 
        [1] => 12 
        [2] => 13 
    )
    */
    //方法 pop 只返回队头数据，并出队列
    print_r($queue->pop());//输出：11
    print_r($queue);
    /*
    原队列输出队列：
    Ds\Queue Object ( 
        [0] => 12 
        [1] => 13 
    )
    */

队列和堆栈入队数据对比

<?php
    $queue = new \Ds\Queue();
    $queue->push(11);
    $queue->push(12,13);
    $queue->push([14,15]);
    print_r($queue);

    
    $stack = new \Ds\Stack();
    $stack->push(11);
    $stack->push(12,13);
    $stack->push([14,15]);
    print_r($stack);

    //输出数据
    //队列数据：
    Ds\Queue Object ( 
        [0] => 11 
        [1] => 12 
        [2] => 13 
        [3] => Array ( 
            [a] => 14 
            [b] => 15 
        ) 
        [4] => Array ( 
            [0] => 16 
            [1] => 17 
        )
    )
    //堆栈数据：
    Ds\Stack Object ( 
        [0] => Array ( 
            [0] => 16 
            [1] => 17 
        ) 
        [1] => Array ( 
            [a] => 14 
            [b] => 15 
        ) 
        [2] => 13 
        [3] => 12 
        [4] => 11
    )
   /*
   结果：
       1.队列先入队的在队头，出队先入先出
       2.堆栈先入栈的在栈尾，出队先入后出
   */