数据结构与算法分析_python_C3

Chapter 3 基本数据结构
3-1 用python实现栈

class Stack():
    def __init__(self):
        self.items = []
        
    def isEmpty(self):
        return self.items == []
    
    def push(self,item):
        self.items.append(item)
        
    def pop(self):
        return self.items.pop()
    
    def peek(self):
        return self.items[len(self.items) - 1]
    
    def size(self):
        return len(self.items)

s = Stack()
s.isEmpty()

s.push(4)
s.push('dog')
s.peek()

s.push(True)
s.size()

s.isEmpty()

s.push(8.4)
s.pop()

s.size()

3-2 栈的另一种实现

class Stack():
    def __init__(self):
        self.items = []
        
    def isEmpty(self):
        return self.items == []
    
    def push(self,item):
        self.items.insert(0,item)
        
    def pop(self):
        return self.items.pop(0)
    
    def peek(self):
        return self.items[0]
    
    def size(self):
        return len(self.items)

3-3 括号匹配

class Stack():
    def __init__(self):
        self.items = []
        
    def isEmpty(self):
        return self.items == []
    
    def push(self,item):
        self.items.append(item)
        
    def pop(self):
        return self.items.pop()
    
    def peek(self):
        return self.items[len(self.items) - 1]
    
    def size(self):
        return len(self.items)

def parChecker(symbolString):
    s = Stack()
    balanced = True
    index = 0
    while index < len(symbolString) and balanced:
        symbol = symbolString[index]
        if symbol == "(":
            s.push(symbol)
        else:
            if s.isEmpty():
                balanced = False
            else:
                s.pop()
                
        index = index + 1
        
        if balanced and s.isEmpty():
            return True
        else:
            return False

3-4 匹配符号

def  parChecker(symbolString):
    s = Stack()
    
    balanced = True
    index = 0
    
    while index < len(symbolString) and  balanced:
        symbol = symbolString[index]
        if symbol in "([[":
            s.push(symbol)
        else:
                if s.isEmpty():
                    balanced = False
                else:
                    top = s.pop()
                    if not matches(top, symbol):
                        balanced = False
                        
                        index = index + 1
    if balanced and s.isEmpty():
        return True
    else:
        return False
    
def matches(open,close):
    opens = "([{"
    closers ="}])"
    
    return opens.index(open) == closers.index(close)

3-5 "除以2"算法的实现

def divideBy2(decNumber):
    remstack = Stack()
    
    while decNumber > 0:
        rem = decNumber % 2
        remstack.push(rem)
        decNumber = decNumber // 2
        
    binString = ""
    while not remstack.isEmpty():
        binString = binString + str(remstack.pop())
        
    return binString    

3-6 将十进制数转换为任意进制数

def baseConverter(decNumber,base):
    digits = "0123456789ABCDEF"
    
    remstack = Stack()
    
    while decNumber > 0:
        rem = decNumber % base
        remstack.push(rem)
        decNumber = decNumber // base
        
    newString = ""
    while not remstack.idEmpty():
        newString = newString + digits[remstack.pop()]
        
    return newString      

3-7 用python实现从中序表达式到后序表达式的转换

class Stack():
    def __init__(self):
        self.items = []
        
    def isEmpty(self):
        return self.items == []
    
    def push(self,item):
        self.items.append(item)
        
    def pop(self):
        return self.items.pop()
    
    def peek(self):
        return self.items[len(self.items) - 1]
    
    def size(self):
        return len(self.items)
    
import string

def infixToPostfix(infixexpr):
    prec = {}
    prec["*"] = 3
    prec["/"] = 3
    prec["+"] = 2
    prec["-"] = 2
    prec["("] = 1
    
    opStack = Stack()
    postfixList = []
    
    tokenList = infixexpr.split()
    
    for token in tokenList:
        if token in string.ascii_uppercase:
            postfixList.append(token)
        elif token == '(':
            opStack.push(token)
        elif token == ')':
            topToken = opStack.pop()
            while topToken != '(':
                postfixList.append(topToken)
                topToken = opStack.pop()
                
        else:
            while (not opStack.isEmpty()) and \
                (prec[opStack.peek()] >= prec[token]):
                    postfixList.append(opStack.pop())
            opStack.push(token)   
            
    while not opStack.isEmpty():
        postfixList.append(opStack.pop())
        
    return " ".join(postfixList)

infixToPostfix("( A + B ) * ( C + D )")

3-8 用python实现后序表达式的计算

 def postfixEval(postfixEval):
    operandStack = Stack()
    
    tokenList = postfixEval.split()
    
    for token in tokenList:
        if token in "0123456789":
            operandStack.push(int(token))
            
        else:
            operand2 = operandStack.pop()
            operand1 = operandStack.pop()
            result = doMath(token, operand1, operand2)
            operandStack.push(result)
            
    return operandStack.pop()

def doMath(op, op1, op2):
    if op == "*":
        return op1 * op2
    elif op == "/":
        return op1 / op2
    elif op == "+":
        return op1 + op2
    else:
        return op1 - op2

3-9 用python实现队列

class Queue:
    def __init__(self):
        self.items = []
        
    def isEmpty(self):
        return self.items == []
    
    def enqueue(self,item):
        self.items.insert(0,item)
        
    def dequeue(self):
        return self.items.pop()
    
    def size(self):
        return len(self.items)  

q = Queue()
q.isEmpty()

q.enqueue('dog')
q = Queue()
q.isEmpty()
q.size()     

3-10 模拟传土豆游戏

from Basic import Queue

def hotPotato(namelist,num):
    simqueue = Queue()
    for name in namelist:
        simqueue.enqueue(name)
        
    while simqueue.size() > 1:
        for i in range(num):
            simqueue.enqueue(simqueue.dequeue())
    
        simqueue.dequeue()
        
    return simqueue.dequeue()

hotPotato(["Bill","Daval","Susu","Keke","Dada"], 6)    

3-11 Printer类

class Printer:
    def __init__(self,ppm):
        self.pagerate = ppm
        self.currentTask = None
        self.timeRemaining = 0
        
    def tick(self):
        if self.currentTask != None:
            self.timeRemaining = self.timeRemaining - 1
            self.timeRemaining <= 0
            self.currentTask = None
            
    def busy(self):
        if self.currentTask != None:
            return True
        else:
            return False
        
    def startNext(self,newtask):
        self.currentTask = newtask
        self.timeRemaining = newtask.getPages() * 60/self.pagerate

import random
random.randrange(1,21)        

3-12 Task类

import random
class Task:
    def __init__(self,time):
        self.timestamp = time
        self.pages = random.randrange(1,21)
        
    def getStamp(self):
        return self.timestamp
    
    def getPages(self):
        return self.pages
    
    def waitTime(self,currenttime):
        return currenttime - self.timestamp  

3-13 打印任务模拟程序

from Basic import Queue

import random 

def siumlation(numSeconds, pagesPerMinute):
     
    labprinter = Printer(pagesPerMinute)
    printQueue = Queue()
    waitingtimes =[]
    
    for currentSecond in range(numSeconds):
        
        if newPrintTask():
            task = Task(currentSecond)
            printQueue.enqueue(task)
            
        if (not labprinter.busy()) and (not printQueue.isEmpty()):
            nexttask = printQueue.dequeue()
            waitingtimes.append(nexttask.waitTime(currentSecond))
            labprinter.startNext(nexttask)
            
        labprinter.tick()
        
    averageWait = sum(waitingtimes) / len(waitingtimes)
    print("Average Wait %6.2f secs %3d tasks remaining " % (averageWait, printQueue.size()))
    
def newPrintTask():
    num = random.randrange(1,181)
    if num == 180:
        return True
    else:
        return False
        

for i in range(10):
    siumlation(3600,10)    

3-14 实现双端队列

class Deque:
    def __init__(self):
        self.items = []
        
    def isEmpty(self):
        return self.items == []
    
    def addFront(self,item):
        self.items.append(item)
        
    def addRear(self,item):
        self.items.insert(0,item)
       
    def removeFront(self):
        return self.items.pop()
    
    def removeRear(self):
        return self.items.pop(0)
    
    def size(self):
        return len(self.items)   

d = Deque()
d.isEmpty()

d.addRear(4)
d.addFront(True)
d.size()

3-15 回文检测器

from Basic import Deque

def palchecker(aString):
    chardeque = Deque()
    
    for ch in aString:
        chardeque.addRear(ch)
        
    stillEqual = True
    
    while chardeque.size() > 1 and stillEqual:
        first = chardeque.removeFront()
        last = chardeque.removeRear()
        if first != last:
            stillEqual = False
            
    return stillEqual

palchecker("lsdkj")      

3-16 Node类

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

temp = Node(9)
temp.getData()    

3-17 UnorderedList类的构造方法

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

3-18 isEmpty构造方法

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

3-19 add构造方法

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

3-20 length方法

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

3-21 search方法

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

3-22 remove方法

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

UnorderedList()

3-23 OrderedList类构造方法

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

3-24 有序列表的search方法

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

3-25 有序列表的add方法

def add(self,item):
    current = self.head
    previous = None
    stop = False
    while current != None and not stop:
        if current.getData() > item:
            stop = True
        else:
            previous = current
            current = current.getNext()
            
    temp = Node(item)
    if previous == None:
        temp.setNext(self.head)
        self.head = temp
        
    else:
        temp.setNext(current)
        previous.setNext(temp)

Basic函数

class Queue:
    def __init__(self):
        self.items = []

    def isEmpty(self):
        return self.items == []

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

    def dequeue(self):
        return self.items.pop()

    def size(self):
        return len(self.items)


class Deque:
    def __init__(self):
        self.items = []

    def isEmpty(self):
        return self.items == []

    def addFront(self, item):
        self.items.append(item)

    def addRear(self, item):
        self.items.insert(0, item)

    def removeFront(self):
        return self.items.pop()

    def removeRear(self):
        return self.items.pop(0)

    def size(self):
        return len(self.items)