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)