数据结构

线性列表

#无序线性表(无序指的是没有顺序), 堆栈(受限的线性表)
#线性列表属性的设置
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
        #print(self.next)

class UnorderedList:

    def __init__(self):
        self.head = None

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

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

    def size(self):
        #每一个元素的head,只知道当前的head,如何知道下一个head,知道下一个元素get.next的head
        count=0
        current=self.head
        while current is not None:
            count+=1
            current=current.getNext()#什么数学原理,和求和很类似
        return count

    def search(self, item):
        #第一个  获取数值current=self.head , 出肉current.getData
        #下一个  current=current.getNext , current.getData
        #在下一个 current=current.getNext, current.getData
        current=self.head
        while current.getData() !=item:
            current=current.getNext()
            if current is None:
                return False
        return True


    def remove(self, item):
        #要删除的元素的next赋给上一个元素的next,即可造成删除的假象
        #那么现在找出这个元素
        front_current=None
        current=self.head
        found=False
        while not found:
            if current.getData()!=item and current is not None:
                front_current=current
                current=front_current.getNext()
            else:
                front_current.setNext(current.getNext())
                return True
            if current is None:
                found =True
        return False

mylist = UnorderedList()
mylist.add(13)
mylist.add(122)
mylist.add(333)
mylist.add(234)
mylist.add(124)

print (mylist.size())
print (mylist.search(333))
print (mylist.remove(122))
print (mylist.remove(1))
print (mylist.size())#获取下一个对象

栈的实现

栈是一种特殊的列表，栈内的元素只能通过列表的一端访问，这一端称为栈顶。咖啡厅内的一摞盘子是现实世界中常见的栈的例子。只能从最上面取盘子，盘子洗净 后，也只能摞在这一摞盘子的最上面。栈被称为一种后入先出（LIFO，last-in-first-out）的数据结构。

class Stack():
    def __init__(self):
        self.item=[]

    def push(self, x):
        self.item.append(x)

    def pop(self):
        if not self.item:
            return
        self.item.pop()

    def peek(self):
        if not self.item:
            return
        return self.item[len(self.item)-1]

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

    def isEmpty(self):
        return len(self.item) == 0


s=Stack()
s.push(2)
s.push(3)
s.pop()
print (s.item)
print (s.peek())
print (s.size())
print (s.isEmpty())

 

队列的实现

队列是一种列表，不同的是队列只能在队尾插入元素，在队首删除元素。队列用于存储按顺序排列的数据，先进先出，这点和栈不一样，在栈中，最后入栈的元素反 而被优先处理。可以将队列想象成在银行前排队的人群，排在最前面的人第一个办理业务，新来的人只能在后面排队，直到轮到他们为止。

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

    def dequeue(self):
        if not self.item:
            return
        return self.item.pop()

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

    def isEmpty(self):
        return len(self.item) == 0

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

q=Queue()
q.enqueue(3)
print (q.item)
q.enqueue(4)
print (q.item)
q.dequeue()
print (q.item)
q.dequeue()
print (q.item)
q.dequeue()

双端队列

双端队列（Deque），是一种类似于队列的元素的有序集合。它拥有两端，队首和队尾，并且元素保持在当前的位置。双端队列的一个不同点就是，添加和删除元素的位置不受限制。

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

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

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

    def removeFront(self):
        if not self.item:
            return
        self.item.pop()

    def removeRear(self):
        if not self.item:
            return
        self.item.pop(0)

    def isEmpty(self):
        return len(self.item) == 0

    def sieze(self):
        return len(self.item)

d=Deque()
d.addFront(2)
print(d.item)
d.addFront(3)
print(d.item)
d.addRear(4)
print (d.item)
d.removeFront()
print (d.item)
d.removeRear()
print (d.item)
d.removeFront()
print (d.item)