python 算法 day1

python实现队列（Queue）

设定队列的队尾在列表的0位置，我们可以使用insert函数向队列的队尾插入新添加的元素，而pop则可以用来移除队首的元素（也就是列表的最后一个元素）也意味着enqueue的复杂度为O（n），而dequeue的复杂度是O（1）

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.enqueue(4)
q.enqueue("dog")
q.enqueue(True)
print(q.size())
print(q.isEmpty())
print(q.items)
q.dequeue()
print(q.items)

一个用队列简单解决的热土豆问题

热土豆问题有一个热土豆在几名同学手中传递，当传过num次数后，热土豆在谁手里就退出游戏，循环传递直到剩下最后一个就是赢家

from pythonds.basic.queue import Queue
def hotpototo(namelist,num):
    simpq = Queue()
    for name in namelist:
        simpq.enqueue(name)
    while simpq.size() > 1:
        for i in range (num):
            simpq.enqueue(simpq.dequeue())
        simpq.dequeue()
    return simpq.dequeue()
print(hotpototo(["sun","y","j","z","M","q"],7))

双端队列

与队列类似，也是一系列元素的有序组合，其两端称为队首（front）和队尾（rear），元素可以从两端删除，也可以从两端插入，这种混合的线性结构拥有栈和队列的所有功能，但其中数据项不满足“FIFO”或者“LIFO”顺序，插入和删除顺序需要用户自己来维护

使用代码实现双端队列

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

dq = Dequeue()
print(dq.isEmpty())
dq.addFront("boy")
dq.addFront("yeare")
dq.addFront("hello")
print(dq.items)
dq.addRear("dh")
print(dq.items)
dq.RemoveFront()
print(dq.items)
print(dq.size())

用双端队列解决的回文词问题

回文词是指正读和反读都一样的单词，如：radar，toot和madam。

解决方案：采用一个双端队列来存储这个字符串，利用双端队列的对称性从首端取字符和从尾端取字符来进行比较设置一个标记来判断是否继续进行比较

from pythonds.basic.deque import Deque
def wordcheck(word):
    checkQ = Deque()
    for i in word:
        checkQ.addFront(i)
    sign = True
    while checkQ.size()>1 and sign:
        first = checkQ.removeFront()
        last = checkQ.removeRear()
        if first!= last:
            sign = False
    return sign

print(wordcheck("qeqddadadaddedeffrgsdvv"))

print(wordcheck("daad"))

列表LIST

列表是一些元素的集合，每个元素拥有一个与其他元素不同的相对位置，这种类型的列表称为一个无序列表

采用链表实现无序列表

该列表的第一项位置必须被明确指出，从外部指向的第一项被称为链表的头，同样的链表的最后一项需要告诉我们有没有下一个项目

类：节点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

node1 = Node(12)
node1.setData(18)
node2 = Node(13)
node2.setData(56)
node1.setNext(node2)
print(node1.data)
print(node1.next.data)

python的特殊值None在节点类和之后的链表类发挥重要作用，引用None意味着没有下一个节点

类无序列表 UNORDERED LIST

无序列表将由一个节点集合组成，每一个节点采用显式引用连接到下一个节点，只要我们知道第一个节点的位置，那么之后的元素都可以通过连接找到下一个节点

无序列表这个类必须保持对第一个节点的引用

class UnorderedList:
    def __init__(self):
        self.head = None
    #期初建立链表没有一个元素
    def isEmpty(self):
        return self.head == []
    def add(self,item):
        temp = Node(item)
        temp.setNext(self.head)
        self.head = temp
    def size(self):
        current = self.head
        count = 0
        while current != None:#遍历操作
            count = 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
        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())

mylist = UnorderedList()
mylist.add(12)
mylist.add("boy")
mylist.add(25)
mylist.add(69)
mylist.add(True)
print(mylist.size())
mylist.search(25)
print(mylist.search('boy'))
print(mylist.search(55))
print(mylist.Remove(25))
print(mylist.size())

实现size方法时，需要遍历整个链表，首先引入一个计数的，初始值为0，根据当前值是否为None来判断是否到链表的尾端，循换结束后返回了计数值

实现search方法时，使用found来判断我们是否找寻到我们需要的元素，如果未找到继续检查下一个节点，如果找到设置found为True

Remove方法主要考虑如果previous没有移动而found已经为真，即列表的第一个节点就为我们要移除的，直接将head指向下一个，完成移除

抽象数据类型：有序列表

按节点数据的大小来排列的

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 OrderedList:
    def __init__(self):
        self.head = None
    def isEmpty(self):
        return self.head == []
    def size(self):
        count = 0
        current = self.head
        while current!= None:
            current = current.getNext()
            count = count +1
        return count
    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)
    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())

    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
orl = OrderedList()
orl.add(1)
orl.add(10)
orl.add(8)
print(orl.isEmpty())
print(orl.search(8))
orl.add(0)

双端队列

列表LIST

类：节点NODE

类 无序列表 UNORDERED LIST

抽象数据类型： 有序列表

猜你喜欢

类无序列表 UNORDERED LIST

抽象数据类型：有序列表