Python 和 PHP 实现 队列 和 栈 以及 利用栈实现符号匹配算法

<?php
#数据集合，可以理解为只能在一端进行插入或者删除操作
#后进先出
#基本操作：1.进栈 push 2.出栈 pop 3.取栈顶 gettop
#python3 使用一般的列表结构可实现栈 进栈：li.append 出栈：li.pop 取栈顶：li[-1]
#php7 使用数组结构可实现栈 进栈：array_push(array,value) 出栈：array_pop(array) 取栈顶：end(array)
class Stack{
	private $stack = array();
	private $stackMaxTop = 100;
	private $Top = 0;

	#栈是否空
	public function stack_is_null()
	{
		if (count($this->stack) <= 0) {
			return 0;
		} else {
			return 1;
		}
	}
	#进栈
	public function push($value){
		if (empty($value)) {
			return "栈值不能为空";
		}
		if ($this->stackMaxTop == $this->Top) {
			return "栈已满";
		}
		array_push($this->stack,$value);
		++$this->Top;
		return '栈顶的值'.$this->Top;
	}
	#出栈
	public function pop()
	{
		if (!$this->stack_is_null()) {
			return None;
		};
		array_pop($this->stack);

	}
	#取栈顶
	public function get_top()
	{
		if (!$this->stack_is_null()) {
			return None;
		};
		return end($this->stack);
	}
	#返回栈内所有元素
	public function get_stack()
	{
		return $this->stack;
	}
}
#栈的应用--括号匹配问题 
#解决思路 如果是左括号就进栈  如果左右匹配则直接出栈
#()()[]{} 匹配
#([{()}]) 匹配
#[]{ 不匹配
#[(](] 不匹配

public function branch_match($string)
{

	if ((!$arr)) {
		return False;
	}
	$left = [')'=>'(',']'=>'[','}'=>'{'];
	$kh = ['(','[','{'];
	//$string = '([{()}])';
	$i = 0;
	$stack = new Stack();
	$arr = str_split($string);

	while ($i < count($arr)) {
		if (in_array($arr[$i], $kh)) {
			$stack->push($arr[$i]);
		}else{
			$top = $stack->get_top();
			$zf = $arr[$i];
			if (!$stack->stack_is_null()) {
				return False;
			}
			if ($left[$zf] == $top) {
				$stack->pop();
			}else{
				return False;
			}
		}
		//var_dump($stack->get_stack());
		$i++;
	}
	if ($stack->stack_is_null()) {
		return False;
	}else{
		return True;
	}

}

#Python 3
#声明Python类
class Stack:
	def __init__(self):
		self.stack = []
	def push(self,element):
		self.stack.append(element)
	def pop(self):
		return self.stack.pop()
	def get_top(self):
		if len(self.stack) > 0:
			return self.stack[-1]
		else
			return None
	def is_empty():
		return len(self.stack) == 0

#Python实现符号匹配算法
def brance_match(s):
	match = {'}':'{',']':'[',')':'('}
	stack  = Stack()
	for ch in s:
		if ch in {'(','[','{'}:
			stack.push(ch)
		else:
			if stack.is_empty():
				return False
			elif stack.get_top() == match[ch]:
				stack.pop()
			else:
				return False
	if stack.is_empty():
		return True
	else:
		return False

#python  栈结束

# 队列 先进先出
# 仅允许在列表的一端进行插入和另一端进行删除。进行插入的一端为队尾，插入动作称为进队或入队
# 进行 删除的一端称为对头，删除动作称为出队 
# 环形队列：当队尾指针front == Maxsize - 1时候，在前进一个位置就自动到0
# 队首指针前进1：front = （front+1）% Maxsize
# 队尾指针前进1：rear = （rear+1）% Maxsize
# 队空：rear == front
# 队满条件：（rear+1）% Maxsize == front

class Queue{
	private $queue = array();
	private $rear = 0;
	private $front = 0;
	private $size = 0;

	#创建队列
	public function create_queue($size)
	{
		if ($size <= 0 ) {
			return 'NONE';
		}
		for ($i=0; 	$i < $size;	 $i++) 	{ 
			$queue[$i] = $i;
		}
		$this->size = $size;
	}
	#进队
	public function push($value)
	{
		if (!$this->is_filled()) {
			$this->rear = ($this->rear+1) % $this->size;
			$this->queue[$this->rear] = $value;
		} else {
			return False;
		}
	}
	#出队
	public function pop()
	{
		if (!$this->is_empty()) {
			$this->front = ($this->front + 1) % $this->size;
			return $this->queue[$this->front];
		}else{
			return False;
		}
	}
	#d队满
	public function is_filled()
	{
		return ($this->rear+1) % $this->size == $this->front;
	}
	#队空
	public function is_empty()
	{
		return $this->rear == $this->front;
	}
}

#Python 实现队列的类

class Queue:
	def __init__(self,size=100):
		self.queue = [0 for _ in range(size)]
		self.size = size
		self.rear = 0 
		self.front = 0

	def push(self,element):
		if not self.is_filled():
			self.rear = (self.rear + 1) % self.size
			self.queue[self.rear] = element
		else:
			raise IndexError("Queue is Filled")
	def pop(self):
		if not self.is_empty():
			self.front = (self.front+1)%self.size
			return self.queue[self.front]
		else:
			raise IndexError("Queue is empty")

	def is_empty():
		return self.rear == self.front

	def is_filled():
		return (self.rear + 1) % size == front

#Python 队列结束