Python学习日志0128 队列，中缀表达式转后缀表达式

1.栈与队列的区别
（1）栈是只能在表的一端进行插入和删除操作的线性表，即先进后出（FILO），在栈中加入元素叫做入栈，从栈中删除元素叫做出栈。
（2）队列是能从队尾添加数据，从队头删除数据的线性表，即先进先出(FIFO) ，只能查看队头元素
2.普通队列的实现
通过列表完成对队列的实现，分别确定列表的两端为插入端和删除端，并将队列抽象为类，将先先进先出作为队列的方法

#普通队列
class myQuene(object):
    def __init__(self,list = []):
        self.__list = list
    #求队列长度
    def size(self):
        return len(self.__list)
    #删除头元素
    def __delete__(self):
        if self.size == 0:
            print("空队列，不能删除")
        else:    
            temp_delete = self.__list[0]
            del self.__list[0]
            return temp_delete
    #追加
    def insert(self,data):
        self.__list.append(data)
    #查看
    def peek(self):

        if self.size == 0:
            print("空队列")
        else:
            return self.__list[0]

q = myQuene()
q.insert(1)
q.insert(2)
q.insert(3)
q.insert(4)
print(q.__delete__())
print(q.__delete__())
print(q.__delete__())
print(q.__delete__())

3.优先级队列的实现
将元素在队列中的先后顺序作为优先级顺序（例如数字由小到大的顺序），将优先级最高的放在队头优先查找或删除。

#优先级队列
class myQuene(object):
    def __init__(self,list = []):
        self.__list = list
    def size(self):
        return len(self.__list)
    #删除头元素
    def __delete__(self):
        if self.size == 0:
            print("空队列，不能删除")
        else:
            temp_delete = self.__list[0]
            del self.__list[0]
            return temp_delete
    #追加  设定数字越小，优先级越高
    def insert(self,data):
        if self.size() == 0:
            self.__list.append(data) #若队列为空，将数据直接插入
        else:
            temp = -1
            for i in range(len(self.__list)):
               if self.__list[i]>data:
                   temp = i
                   break
            if temp == -1:
                self.__list.append(data)
            else:
                self.__list.insert(temp,data)


    #查看
    def peek(self):
        def __delete__(self):
            if self.size == 0:
                print("空队列")
            else:
                return self.__list[0]


q = myQuene()
q.insert(1)
q.insert(3)
q.insert(4)
q.insert(2)
print(q.__delete__())
print(q.__delete__())
print(q.__delete__())
print(q.__delete__())

4.循环队列

可将循环队列想象为首尾相接的环形队列。循环队列中front 指针指向队头元素， rear 指针指向队尾元素的下一个位置

循环队列的优点：在删除数据时无需改变队列中所有元素的位置，只需改变对队头的指向，提高效率。

class xunhuan():
    def __init__(self,list=[],first=None,last=None):
        self.__list = list
        self.__last = last
        self.__first = first
    def size(self):
        length = 0
        if self.__last > self.__first:
            length = self.__last-self.__first+1
        elif self.__last == self.__first and self.__last != None:
            length = 1
        elif self.__last == self.__first and self.__last == None:
            length =0
        else:
            length = len(self.__list)-(self.__first - self.__last-1)
        return length

    def insert(self,data):
        if self.size()==0:
            self.__list.append(data)
            self.__first = 0
            self.__last = 0
        else:
            if self.size()==len(self.__list):
                self.insert(self.__last+1,data)
                self.__last = self.__last+1
            else:
                if self.__last+1==len(self.__list):
                    self.__list[0] = data
                    self.__last = 0
                else:
                    self.__list[self.__last+1] = data
                    self.__last = self.__last+1

    def delete(self):
        if self.size() == 0:
            print("空队列，无法删除")
        elif self.size() == 1:
            temp = self.__list[self.__first]
            self.__first = None
            self.__last = None
            return temp
        else:
            temp = self.__list[self.__first]
            if self.__first+1==len(self.__list):
                self.__first = 0
            else:
                self.__first = self.__first+1
            return temp

    def peek(self):
        if self.size() == 0:
            print("空队列")
        else:
            return self.__list[self.__first]

5.中缀表达式转后缀表达式

编程思路：

（1）遇到操作数（要计算的数字）直接拼到字符串

（2）遇到运算符

a.遇到左括号   

b.遇到右括号

c.遇到+ -

d.遇到* /

（3）计算后缀表达式

def middle2after(s=""):  #s代表一个中缀表达式  s为字符串类型

    str = ""    #接收后缀表达式的字符串
    list = []
    for item in s:  #循环s
        #遇到操作数
        if item.isalnum():
            str += item   #遇到数字直接叠加
        else:
            if item == "(":
                list.append(item)  #遇到左括号直接入栈
            elif item == ")":
                while list[-1] !="(":
                    str += list.pop()
                list.pop()  #删除左括号
            elif item in "+-":
                if len(list) == 0:
                    list.append(item)
                else:
                    while len(list)!=0 and list[-1] != "(":
                        str += list.pop()
                    list.append(item)

            elif item in "*/":
                list.append(item)  #遇到*/直接入栈

            else:
                print("表达式有问题")  #出现操作数  +-*/（）以外的字符
    while len(list)!=0:
        str += list.pop()
    return str

def cal(s=""):
    stack = []  #stack为栈
    for item in s:
        if item.isalnum():
            stack.append(item)
        else:
            a = float(stack.pop())
            b = float(stack.pop())

            if item == "-":
                c = b - a

            elif item == "+":
                c = b + a
            elif item == "*":
                c = b * a
            elif item == "/":
                c = b / a
            else:
                print("后缀表达式有问题")
            stack.append(c)
    return stack.pop()

str = middle2after("1+3*40")
print(str)
print(cal(str))