PHP Stack::last方法代码示例

 /**
  * @link http://php.net/manual/en/iterator.rewind.php
  * @return void
  */
 function rewind()
 {
     $this->stack = new LinkedStack();
     $this->pushLeft($this->root);
     if (!$this->stack->isEmpty()) {
         $this->node = $this->stack->last();
         $this->key = 0;
     }
 }

 /**
  * @link http://php.net/manual/en/iterator.next.php
  * @return void
  */
 function next()
 {
     /**
      * @var BinaryTree $node
      */
     $node = $this->stack->pop();
     $this->pushIfNotNull('right', $node);
     $this->pushIfNotNull('left', $node);
     if ($this->stack->isEmpty()) {
         $this->value = $this->key = null;
         return;
     }
     $this->value = $this->stack->last();
     $this->key++;
 }

 private function next_right()
 {
     $right = $this->value->right();
     if ($right !== null && !$this->stack->isEmpty() && $right === $this->stack->last()) {
         $this->stack->pop();
         $this->next_push($right);
     } else {
         $this->next_set();
     }
 }

 public function nfx($expr)
 {
     $index = 0;
     $stack = new Stack();
     $output = array();
     // postfix form of expression, to be passed to pfx()
     // $expr = trim(strtolower($expr));
     $expr = trim($expr);
     $ops = array('+', '-', '*', '/', '^', '_');
     $ops_r = array('+' => 0, '-' => 0, '*' => 0, '/' => 0, '^' => 1);
     // right-associative operator?
     $ops_p = array('+' => 0, '-' => 0, '*' => 1, '/' => 1, '_' => 1, '^' => 2);
     // operator precedence
     $expecting_op = false;
     // we use this in syntax-checking the expression
     // and determining when a - is a negation
     if (preg_match("/[^\\w\\s+*^\\/()\\.,-]/", $expr, $matches)) {
         // make sure the characters are all good
         return $this->trigger("illegal character '{$matches[0]}'");
     }
     while (1) {
         // 1 Infinite Loop ;)
         $op = substr($expr, $index, 1);
         // get the first character at the current index
         // find out if we're currently at the beginning of a number/variable/function/parenthesis/operand
         $ex = preg_match('/^([A-Za-z]\\w*\\(?|\\d+(?:\\.\\d*)?|\\.\\d+|\\()/', substr($expr, $index), $match);
         //===============
         if ($op == '-' and !$expecting_op) {
             // is it a negation instead of a minus?
             $stack->push('_');
             // put a negation on the stack
             $index++;
         } elseif ($op == '_') {
             // we have to explicitly deny this, because it's legal on the stack
             return $this->trigger("illegal character '_'");
             // but not in the input expression
             //===============
         } elseif ((in_array($op, $ops) or $ex) and $expecting_op) {
             // are we putting an operator on the stack?
             if ($ex) {
                 // are we expecting an operator but have a number/variable/function/opening parethesis?
                 $op = '*';
                 $index--;
                 // it's an implicit multiplication
             }
             // heart of the algorithm:
             while ($stack->count > 0 and $o2 = $stack->last() and in_array($o2, $ops) and $ops_r[$op] ? $ops_p[$op] < $ops_p[$o2] : $ops_p[$op] <= $ops_p[$o2]) {
                 $output[] = $stack->pop();
                 // pop stuff off the stack into the output
             }
             // many thanks: http://en.wikipedia.org/wiki/Reverse_Polish_notation#The_algorithm_in_detail
             $stack->push($op);
             // finally put OUR operator onto the stack
             $index++;
             $expecting_op = false;
             //===============
         } elseif ($op == ')' and $expecting_op) {
             // ready to close a parenthesis?
             while (($o2 = $stack->pop()) != '(') {
                 // pop off the stack back to the last (
                 if (is_null($o2)) {
                     return $this->trigger("unexpected ')'");
                 } else {
                     $output[] = $o2;
                 }
             }
             if (preg_match("/^([A-Za-z]\\w*)\\(\$/", $stack->last(2), $matches)) {
                 // did we just close a function?
                 $fnn = $matches[1];
                 // get the function name
                 $arg_count = $stack->pop();
                 // see how many arguments there were (cleverly stored on the stack, thank you)
                 $output[] = $stack->pop();
                 // pop the function and push onto the output
                 if (in_array($fnn, $this->fb)) {
                     // check the argument count
                     if ($arg_count > 1) {
                         return $this->trigger("too many arguments ({$arg_count} given, 1 expected)");
                     }
                 } elseif (array_key_exists($fnn, $this->f)) {
                     if ($arg_count != count($this->f[$fnn]['args'])) {
                         return $this->trigger("wrong number of arguments ({$arg_count} given, " . count($this->f[$fnn]['args']) . " expected)");
                     }
                 } else {
                     // did we somehow push a non-function on the stack? this should never happen
                     return $this->trigger("internal error");
                 }
             }
             $index++;
             //===============
         } elseif ($op == ',' and $expecting_op) {
             // did we just finish a function argument?
             while (($o2 = $stack->pop()) != '(') {
                 if (is_null($o2)) {
                     return $this->trigger("unexpected ','");
                 } else {
                     $output[] = $o2;
                 }
                 // pop the argument expression stuff and push onto the output
             }
//.........这里部分代码省略.........

        } else {
            echo "stack is empty";
        }
    }
    public function isEmpty()
    {
        if ($this->index == -1) {
            return true;
        } else {
            return false;
        }
    }
    public function first()
    {
        echo $this->stackArray[$this->index];
    }
    public function last()
    {
        echo $this->stackArray[0];
    }
}
$newStack = new Stack();
$newStack->push(2);
$newStack->push(6);
$newStack->pop();
$newStack->pop();
$newStack->pop();
$newStack->isEmpty();
$newStack->first();
$newStack->last();
$newStack->getElement(1);

            $this->index--;
            return $element;
        }
        echo "There is no element in the quee array";
    }
    public function isEmpty()
    {
        if ($this->index == -1) {
            return true;
        } else {
            return false;
        }
    }
    public function first()
    {
        return $this->queArray[$this->index];
    }
    public function last()
    {
        return $this->queArray[0];
    }
}
$muy = new Stack(array(3, 4, 7));
$myStack = new Stack();
$myStack->push(1);
$myStack->push(4);
echo $myStack->first(), "<br>";
echo $myStack->last(), "<br>";
echo $myStack->pop(), "<br>";
echo $myStack->pop(), "<br>";
$myStack->pop();