Python数据结构与算法分析（第二版）学习笔记——基本数据结构习题

我们要实现一个算法，功能包括对中序表达式进行转换，再对完成转换的后序表达式进行计算。我们对之前写过的代码进行整合，在后序表达式的转换中，我们要把识别大写字母改成识别数字，输出结果是一个字符串，元素间用空格间隔，并将这个结果输入到后序表达式的计算中。

def domath(way,num1,num2):
    if way == "+":
        return num1 + num2
    elif way == "-":
        return num1 - num2
    elif way == "*":
        return num1*num2
    elif way == "/":
        return num1 / num2

# print(postfixEval("1 1 +"))
#

# 直接计算
def infixToPostfixnum(x):
    s = Stack()
    finlist = []
    prec = {
        "*":3,
        "/":3,
        "+":2,
        "-":2,
        "(":1
        }

    for token in x.split():
        if token in "0123456789":
            finlist.append(token)
        elif token == "(":
            s.push(token)
        elif token == ")":
            las = s.pop()
            while las != "(":
                finlist.append(las)
                las = s.pop()
        elif token in "+-*/":
            while not s.isEmpty() and prec[s.peek()] >= prec[token]:
                finlist.append(s.pop())
            s.push(token)
        else:
            return "请输入正确的数字、符号"

    while not s.isEmpty():
        finlist.append(s.pop())
    numlist =  " ".join(finlist)
    # print(infixToPostfixnum("3 + 4"))
    s = Stack()
    tokenlist = numlist.split()

    for i in tokenlist:
        if i in "0123456789":
            s.push(int(i))
        else:
            num2 = s.pop()
            num1 = s.pop()
            newnum = domath(i,num1,num2)
            s.push(newnum)

    return s.pop()

列表后端作列队尾部：

# -*- codeing = utf-8 -*-
class queuerev:
    def __init__(self):
        self.item = []

    def enqueue(self,item):
        self.item.insert(0,item)

    def dequeue(self,item):
        return self.item.pop()

要实现土豆案例的随机，只需要引入随机函数，并将数字间隔改为随机函数。

import random
def hotpotatorand(namelist):
    q = Queue()

    for name in namelist:
        q.enqueue(name)

    while q.size() > 1:
        for i in range(random.randint(1,10)):
            q.enqueue(q.dequeue())
        q.dequeue()

    return q.dequeue()

在回文判断的案例中，要避免空格造成的误判，只要在遍历字符串插入双端列表的时候加入判断，跳过空格即可。

def palcheckerpro(astring):
    chardeque = Deque()
    for i in astring:
        if i == " ":
            continue
        chardeque.addRear(i)

    hw = True

    while hw and chardeque.size() > 1:

        f = chardeque.removeFront()
        r = chardeque.removeRear()



        if f != r :
            return False
    return hw

列表的切片方法，可以在length的基础上完成这个切片。用while循环，当计算count小于end时就可以执行这个过程，如果count大于等于start值则将当前的Data加入列表。

class Node:
    def __init__(self,initdata):
        self.data = initdata
        self.next = None

    def getData(self):
        return self.data
    def getNext(self):
        return self.next
    def setData(self,newdata):
        self.data = newdata
    def setNext(self,newnext):
        self.next = newnext

class UnorderList:
    def __init__(self):
        self.head = None

    def isEmpty(self):
        return self.head == None

    def add(self,item):
        temp = Node(item)
        temp.setNext(self.head)
        self.head = temp

    def length(self):
        current = self.head
        count = 0
        while current != None:
            count += 1
            current = current.getNext()
        return count

    def search(self,item):
        current = self.head
        found = False
        while current != None and not found:
            if current.getData() == item:
                found = True
            else:
                current = current.getNext()
        return found

    def remove(self,item):
        current = self.head
        pro = None
        found = False
        while current != None and not found:
            if current.getData() == item:
                found = True
            else:
                pro = current
                current = current.getNext()
        if pro == None:
            self.head = current.getNext()
        else:
            pro.setNext(current.getNext())

    def getpos(self,item):
        current = self.head
        count = 0
        while count != item:
            count += 1
            current = current.getNext()
        return current.getData()

    def slice(self,start,end):
        current = self.head
        count = 0
        finlist = []
        while count < end:
            if count >= start:
                finlist.append(current.getData())
            count += 1
            current = current.getNext()
        return finlist

对无序列表进行完善。在搭建append的方法时，我们需要遍历到最后一个元素，给新元素添加头部指向空，而之前的元素要指向新创建的元素。不过，当处于最后一个元素时，不能使用getNext。

# -*- codeing = utf-8 -*-
class Node:
    def __init__(self,initdata):
        self.data = initdata
        self.next = None

    def getData(self):
        return self.data
    def getNext(self):
        return self.next
    def setData(self,newdata):
        self.data = newdata
    def setNext(self,newnext):
        self.next = newnext

class UnorderList:
    def __init__(self):
        self.head = None
        self.mylength = 0

    def isEmpty(self):
        return self.head == None

    def add(self,item):
        temp = Node(item)
        temp.setNext(self.head)
        self.head = temp
        self.mylength +=1
    def insert(self,num,item):
        current = self.head
        found = False
        count = 0

        while current != None and not found:
            if count == num:
                found = True
            else:
                count += 1

                current = current.getNext()
        node = Node(item)
        now = current.getNext()
        current.setNext(node)
        node.setNext(now)

        self.mylength += 1
    def append(self,item):
        current = self.head

        while current != None:
            current = current.getNext()
        temp = Node(item)
        temp.setNext(self.head)
        self.head = temp

        self.mylength += 1
    def pop(self):
        current = self.head
        pro = None
        find = False

        while current != None and not find:
            if current.getNext() == None:
                find = True
            else:
                pro = current
                current = current.getNext()

        pro.setNext(current.getNext())

        self.mylength -= 1




    def length(self):
        current = self.head
        self.mylength = 0
        while current != None:
            self.mylength += 1
            current = current.getNext()
        return self.mylength

    def search(self,item):
        current = self.head
        found = False
        while current != None and not found:
            if current.getData() == item:
                found = True
            else:
                current = current.getNext()


        return found

    def remove(self,item):
        current = self.head
        pro = None
        found = False
        while current != None and not found:
            if current.getData() == item:
                found = True
            else:
                pro = current
                current = current.getNext()
                self.mylength -= 1
        if pro == None:
            self.head = current.getNext()
        elif found == False:
            return "元素不存在"
        else:
            pro.setNext(current.getNext())
            self.mylength -= 1

            return "成功了"

    def index(self,item):
        current = self.head
        count = 0
        find = False
        while current != None and not find:
            if count != item:
                count += 1
                current = current.getNext()
            else:
                find = True

        return current.getData()

    def slice(self,start,end):
        current = self.head
        count = 0
        finlist = []
        while count < end:
            if count >= start:
                finlist.append(current.getData())
            count += 1
            current = current.getNext()
        return finlist