数据结构

列表

列表中元素是如何存储的？       #内存地址不连续
列表提供了哪些基本的操作？
这些操作的时间复杂度是多少？ #增，insert是O(n)，append是O(1)，所以insert比append要慢。
                                        #删，remove是O(n)，pop是O(1)，所以remove比pop要慢。
                                        #改，O(1)
                                        #查，O(n)

栈

栈(Stack)是一个数据集合，可以理解为只能在一端进行插入或删除操作的列表。
栈的特点：后进先出（last-in, first-out）
栈的概念：
      栈顶
      栈底
栈的基本操作：
      进栈（压栈）：push
      出栈：pop
      取栈顶：gettop
栈在python中的实现：
      不需要自己定义，使用列表结构即可。
      进栈函数：append
      出栈函数：pop
      查看栈顶函数：li[-1]

stack = []             # 创建一个栈

stack.append(1)        # 进栈
stack.append(2)        # 进栈
stack.append(3)        # 进栈

print(stack.pop())     # 出栈

print(stack[-1])       # 查看栈顶

栈的应用：
      列表倒序
      括号匹配问题

# 括号匹配问题

def bracket(strings):
    stack = []
    for s in strings:
        if s in ['(', '[', '{']:
            stack.append(s)          #进栈
        elif s == ')':
            if stack and stack[-1] == '(':
                stack.pop()          #当循环到')'时，栈顶必须是'('才能匹配成'()'，然后把'('从栈拿出。
            else:                    #如果栈是空的，或者栈顶不是')'，表示没有匹配上
                return False
        elif s == ']':
            if stack and stack[-1] == '[':
                stack.pop()
            else:
                return False
        elif s == '}':
            if stack and stack[-1] == '{':
                stack.pop()
            else:
                return False
    #最后判断栈是否空了，如果没空，说明还有没匹配上的
    if not stack:
        return True
    else:
        return False

队列

队列(Queue)是一个数据集合，仅允许在列表的一端进行插入，另一端进行删除。
进行插入的一端称为队尾(rear)，插入动作称为进队或入队
进行删除的一端称为队头(front)，删除动作称为出队
队列的性质：先进先出(First-in, First-out)

双向队列：队列的两端都允许进行进队和出队操作。

队列的基本原理：

初步设想：列表+两个下标指针
      创建一个列表和两个变量，front变量指向队首，rear变量指向队尾。初始时，front和rear都为0。
      进队操作：元素写到li[rear]的位置，rear自增1。
      出队操作：返回li[front]的元素，front自减1。

当出对后，内存仍然被占用着。

队列在python中的实现：

from collections import deque

que = deque()

que.append(1)   #进队
que.append(2)   #进队
que.append(3)   #进队

que.popleft()   #出队

链表

链表中的每一个元素都是一个对象，每个对象称为一个节点，节点包含数据和指向下一个节点的指针next。通过各个节点之间的相互连接，最终串联成一个链表。

节点定义：

class Node(object):
    def __init__(self, item):
	self.item = item
	self.next = None

头结点：不存数据

#遍历链表

class Node():
    def __init__(self, item=None):
        self.item = item
        self.next = None

head = Node()   # 头节点不存数据
head.next = Node(10)
head.next.next = Node(20)
head.next.next.next = Node(30)

def traversal(head):
    curNode = head
    while curNode:
        print(curNode.item)
        curNode = curNode.next

traversal(head)

链表节点的插入和删除
    插入：
	p.next = curNode.next    #p是要插入的节点
	curNode.next = p

    删除：
	p = curNode.next         #p是要删除的节点
	curNode.next = curNode.next.next
	del p

字符串：

    def partition(self, sep):
        """
        S.partition(sep) -> (head, sep, tail)
        
        Search for the separator sep in S, and return the part before it,
        the separator itself, and the part after it.  If the separator is not
        found, return S and two empty strings.