4 Python基本数据结构

运行前，在python文件夹下通过pip install pythonds包。

4.1栈

栈的结构特性是“先进后出”。这一特性可以应用在结果只是二元的情况中，如（）的判断，遇到（压栈，遇到）则出栈，通过栈是否为空来判断（）是否成对，又如十进制化成二进制，因为余数只是1或0。
实现栈的代码如下所示：

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

这里注意到，在pythonds包里的Stack()类的pop()函数采用数组pop()来编写的，为了保证栈先进后出的特性，因此栈的元素是呈从左向右为先到后的关系，即1,2,3,4…最先添加进去的1在最左边。

4.2 队列

与栈区别的话，队列的是一个两端都可以操作的数组，队的特点是“先进先出”，实现代码如下：

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)

其中，代码采用数列的pop()来出队，即在列表的尾部操作为最先的元素，故进队的元素必须在列表头部，故采用insert(0,)函数。总之，队的元素呈现从左到右依次为后到先的顺序，即…4,3,2,1最先进队的是1。

4.3双端队列

双端队列有一前一后两端，元素在各个端进行相应的队列操作(先进先出)。双端队列的出队操作也是用pop()函数编写的，因此和队列一样，它的前后端的顺序均为从左向右为后到先的顺序。

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

4.4栈、队列和双端队列的区别

4.5链表

4.5.1节点

为了完成无序链表的元素既要有数据，又要知道下一个元素位置而专门定义了一个类。①节点包含两个属性，data和next来对应它的特性。②在注意两个get函数，getNext返回的是self.next这个节点一般用于遍历列表。③初始化的时候，默认self.next=None，而又定义了一个setNext函数来设置下一个节点，由类的特性，在设置下一节点的时候，可以采用两种方式，如代码①②。

class Node:
    def __init__(self,data):
        self.data = data
        self.next = None
    def getData(self):
        return self.data
    def getNext(self):
        return self.next
    def setData(self,data):
        self.data = data
    def setNext(self,node):
        self.next = node
        
	a = Node(1)
	b = Node(2)
	c = Node(3)
	①	
	# a.setNext(b)
	# b.setNext(c)
	②
	a.next = b
	b.next = c
	print(a.next.next.getData)

4.5.2无序链表

以1,2,3的顺序添加元素，第一个进去的是1，但是作为头节点的却是最后一个进去的3。

class UnorderedList:
    def __init__(self):
        self.head = None
    def addData(self,data):
        temp = Node(data)
        temp.setNext(self.head)
        self.head = temp
    def isEmpty(self):
        return self.head == None
    def length(self):
        current = self.head
        count = 0
        while current != None:
            count = count + 1
            current = current.getNext()
        return count
    def search(self,data):
        current = self.head
        found = False
        while current != None and not found:
            if current.getData() == data:
                found = True
            else:
                current = current.getNext()
        return found
            def remove(self,data):
        current = self.head
        pre = None
        found = False
        while not found:
            if current.getData() == data:
                found = True
            else:
                pre = current
                current = current.getNext()
        if pre == None:
            self.head = current.getNext()
            print("i am head")
        else:
            pre.setNext(current.getNext())

a = UnorderedList()
a.addData(1)
a.addData(2)
a.addData(3)
print(a.head.getData())
运行结果：3
a.remove(3)
运行结果：i am head

4.5.3有序链表

有序链表和无序链表其本质的区别在于添加元素时的方法不一样，无序链表添加元素是通过头结点来实现的，而有序链表在添加元素时要先查找这个元素应该放置的位置，然后断开链表把元素添加进去。现在分析有序链表的查找元素方法(search)和添加元素的方法(addData)。

def search(self,item):
    current = self.head
    stop = False
    found = False
    while current != None and not found and stop:
        if item == current.getData():
            ##表示直接找到了
            found = True
        else:
##有序表特点，如果大于了item再next也是大于的
            if current.getData() > item:
##剩下的不会等于，没必要继续search下去了
                stop = True
            else:
                 current = current.setNext()
     return found
         def addData(self,item):
        current = self.head
        ##pre用于追踪要插入的节点前的位置，并且判断是否是头节点处
        per = None
        stop = False
        while current != None and not stop:
            ##找到插入节点的后面的位置
            if current.getData() > item:
                stop = True
            else:
                pre = current
                current = current.getNext()
        temp = Node(item)
        if pre == None:
            temp.setNext(self.head)
            self.head = temp
        else:
            temp.setNext(current)
            pre.setNext(temp)