数据结构与算法Python版（完整版）P8

 

大O表示法

 

 问题规模

 

 抓大头，数量级

 

 决定运行时间的不仅是问题规模，还跟工况有关，平均状况

常见的七种

P10 变位词判断问题

问题：

解法1

解法2：先排序后比较

 

def  paiXU(s1,s2):
    a=list(s1)
    b=list(s2)
    a.sort()
    b.sort()
    pos=0
    matches=True
    while pos<len(s1) and matches:
        if a[pos] == b[pos]:
            pos=pos+1
            print('jia1')
        else:
            matches=False
    return matches

print(paiXU('wangc','thonpy'))

 P11 变为词的判断问题

解法3，暴力法

 

 解法4

 

def solution4(s1,s2):
    c1=[0]*26;
    c2=[0]*26;
    for i in range(len(s1)):
        pos=ord(s1[i])-ord('a')
        c1[pos]=c1[pos]+1
    for i in range(len(s2)):
        pos=ord(s2[i])-ord('a')
        c2[pos]=c2[pos]+1
    j=0
    stillOk=True
    while j<26 and stillOk:
        if c1[j]==c2[j]:
            j=j+1
        else:
            stillOk=False
    return stillOk
print(solution4('wangc','pleap'))

 P12 Python数据类型的性能上

 

 

 

 

 P12 Python的数据类型下

 

 

 

 

 这一节课没有动手

P14什么是线性结构

 

 四种：栈、队列、列表、双端队列

 P15栈抽象数据类型及Python实现

 加入移除的一段成为栈顶

  长按即可出现列表

 

 

 调用接口即可

 列表和字体是最常见的，

使用列表来实现栈

 

 

 

 P16栈的应用：简单括号匹配

P17栈的应用 十进制转换成二进制

P18栈的应用表达式转换2022.3.5

 

 P19 表达式转换下

 

 

 

 

 手工敲一遍，执行正确后，有什么可以改进的

P20栈的应用-后缀表达式求值

 

 

 

 

 

栈这一单元结束

P21 队列抽象数据类型及python实现

 

 

 

 

 

P22队列的应用 热土豆

 

 

 

from pythonds.basic.queue import Queue
# 为什么是susan
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()
print(hotPotato(['Bill','Davide','Susan','Jane','Kent','Brad'],7))

P23队列的应用 打印任务

 

 

 

 P24队列的应用 打印任务下

 

 

 

 

 

from pythonds.basic.queue import Queue
import  random
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
            if 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
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
def newPrintTask():
    num=random.randrange(1,181)
    if num==180:
        return True
    else:
         return  False
def simulation(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("平均等待时间 %6.2f %3d 剩余任务"\
          %(averageWait,printQueue.size()))
for i in range(10):
    simulation(3600,5)

 

p25 双端队列的抽象数据类型及Python实现+回文词判定

 集成了栈和队列的能力

 

  

 

这个操作复杂度有点不理解 

 

 

from pythonds.basic.deque import Deque
def palChecker(aString):
    charqueue=Deque()
    for ch in aString:
        charqueue.addRear(ch)
    stillEqual=True
    while stillEqual==True and charqueue.size()>1:
        firstChar=charqueue.removeFront()
        lastChar=charqueue.removeRear()
        if firstChar!=lastChar:
            stillEqual=False
    return  stillEqual


print(palChecker("wangc"))
print(palChecker("radar"))

P26 无序表数据类型及python实现

 

 

 

 

 

 

 

 

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 __int__(self):
        self.head = None


mylist=UnorderList()
print(mylist.head)
# ??没法打印
temp=Node(93)
print(temp.getData())
print(temp.getNext())

P27无序表的链表实现

 

 

 

 

 

 

  

    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())

P28有序表抽象类型及Python实现

 

 

 

 自己实现一编书

search \add

 如果是存在的话是一样的

 

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

 

    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 previuous==None:
            temp.setNext(self.head)
            self.head=temp
        else:
            temp.setNext(current)
            previous.setNext=temp

 

 P29 线性结构小结

 

 

 P30什么是递归

2022.3.27

 

 

 

 

 

 

 

 

 P31 递归的应用-任意进制的转换问题

 

 

 

 

 

# 递归的应用
def toString(n,base):
    convertString="0123456789ABCDEF "
    if n<base:
        return convertString[n]
    else:
        b = n % base;
        n=n//base;

        return convertString[b]+toString(n,base);

print(toString(1453,16))

P32递归调用的实现

 

 

 超出最大递归深度

 

 

 P33        分形树

 

 100

 100像素

 

import  turtle
t=turtle.Turtle()
# t.pencolor('red')
# t.pensize(3)
# for i in range(5):
#     t.forward(100)
#     t.right(144)
# t.hideturtle()
# turtle.down
def drawSpiral(t,lineLen):
    if lineLen>0:
        t.forward(lineLen)
        t.right(90)
        drawSpiral(t,lineLen-5)
drawSpiral(t,100)
turtle.down

 

 

 

 

 

 这里我感到不太明白的是怎么回来的

P34递归可视化：谢尔宾斯基三角形