数据结构学习

P46~P51
数据结构：数据＋数据之间的关系
堆是一种特殊的二叉树
数据之间的关系：
①线性结构：数据结构中存在一对一的相关关系，列表
②树结构：数据结构中存在一对多的相关关系
③图结构：（地图）数据结构中存在多对多的相关关系

一、线性结构：
1. 列表
增删改查
由于python的列表中可以存储不同类型的数值，所以python中存储的实际上不是数值本身，而是数值的地址

# 列表增删改查
l=[1,2,3,4,5]
l2=[2]*4
# 增
l.append(6)
l.extend(l2)
l.insert(0,23) # 下标，数值
l+l2
# 删
l.pop(3) # 下标
del l[0]
l.remove(2) # 数值，删除某个元素
# 改
l[0]=2
# 查
l.index(2) # 数值，返回被查元素的首下标
l.count(2) # 数值，计数
# 排序
l.sort(reverse=True) # 降序

2. 栈：只能再一端进行插入或删除操作的列表
栈的概念：栈顶、栈底
栈的基本操作：
进栈（压栈）：push，在栈顶加入元素l.append()
出栈：pop，取走栈顶元素l.pop()
取栈顶：gettop，查看栈顶元素 l[-1]

# 栈的类

class Stack:
    def __init__(self): # 创建一个类的实例对象
        self.stack = []
    def push(self,element): # 进栈
        self.stack.append(element)
    def pop(self): # 出栈
        return self.stack.pop()
    def get_top(self):
        if len(self.stack) > 0: # 非空栈
            return self.stack[-1]
        else:
            return None
    def if_empty(self): # 判断列表是否为空
        return len(self.stack)==0
    def put(self):
        print(self.stack)
    
stack =Stack()
stack.push(1)
stack.push(3)
stack.push(5)
stack.if_empty()
stack.put()

# 匹配括号
s1='({[]})'
s2='[}'
s3='[][{}({}[][({[]})])]'
# 每次只有左括号进栈，右括号与其匹配，匹配成功则左括号出栈，不成功直接返回False
def brace_match(s):
    match={'}':'{',']':'[',')':'('}
    stack=Stack()
    for ch in s:
        if ch in {'(','{','['}:
            stack.push(ch)
        else:
            if stack.if_empty():
                return False # 第一个就是]})不匹配
            elif stack.get_top()==match[ch]:
                stack.pop() # 每次都和左括号匹配，匹配成功则将这个左括号出栈
            else:
                return False
    if stack.if_empty():
        return True
    else:
        return False
print(brace_match(s1))
print(brace_match(s2))
print(brace_match(s3))

3. 队列：一个数据集合，仅允许从队列的一端进行插入，另一端进行删除
队尾：能进行插入的一端，插入动作称为进队或入队
队头：能进行删除的一端，删除动作称为出队
队列的性质：先进先出
环形队列：当rear和front再次碰头时完成了整个进队出队的周期

# 队
class Queue():
    def __init__(self,size):
        self.queue=[0 for i in range(size)]
        self.size =size
        self.rear=0 # 队尾指针
        self.front=0 # 队首指针
        # 判断队空
    def is_empty(self):
        return self.rear == self.front
    # 判断队满
    def is_filled(self):
        return (self.rear+1)%self.size == self.front
    def push(self,element):
        if not self.is_filled():
            self.rear = (self.rear+1)%self.size
            self.queue[self.rear] = element
        else:
            raise IndexError("Queue is empty!")
    def pop(self):
        if not self.is_empty():
            self.front = (self.front + 1)%self.size
            return self.queue[self.front] # 弹出队首
        else:
            raise IndexError("Queue is empty!")
    def put(self):
        print(self.queue)

q=Queue(5)
for i in range(4): # 要少一位否则会判断为满队
    q.push(i)
q.pop()
q.put()

-------------
P57~P58
4. 链表
链表是由一系列节点组成的元素集合。每个节点包含两部分，数据item和指向下一个节点的指针next。通过节点之间的相互连接，最终串联成一个链表。
创建链表的方法：头插法、尾插法

# 链表
class Node():
    def __init__(self,item):
        self.item = item
        self.next = None
a=Node(1)
b=Node(2)
c=Node(3)
a.next=b
b.next=c
'''
a -> b -> c
1 -> 2 -> 3
'''
print(a.next.next.item)

# 将列表以头插法转为链表
# 头插法是倒序
def create_linklist(li):
    head=Node(li[0])
    for element in li[1:]:
        node=Node(element)
        node.next=head
        head=node
    return head
def print_linklist(head):
    while head:
        print(head.item,end=' ')
        head=head.next
lk=create_linklist([1,2,3,4])
'''
4 -> 3 -> 2 -> 1
'''
print_linklist(lk)

# 尾插法是升序
def create_linklist_tail(li):
    head=Node(li[0])
    tail=head
    for element in li[1:]:
        node=Node(element)
        tail.next=node
        tail=node
    return head
lk=create_linklist_tail([1,2,3,4])
print_linklist(lk)

5. 哈希表

——————————————————————————————
P65~P72
二、树结构

# 二叉树
class BiTreeNode:
    def __init__(self,data):
        self.data=data
        self.lchild=None
        self.rchild=None

a=BiTreeNode('a')
b=BiTreeNode('b')
c=BiTreeNode('c')
d=BiTreeNode('d')
e=BiTreeNode('e')
f=BiTreeNode('f')
g=BiTreeNode('g')

e.rchild=g
e.lchild=a
a.rchild=c
c.rchild=d
c.lchild=b
g.rchild=f

root=e
print(root.lchild.rchild.data)

1. 二叉树

# 前序遍历
def pre_order(root):
    if root:
        print(root.data)
        pre_order(root.lchild)
        pre_order(root.rchild)
pre_order(root) # e a c b d g f 

# 中序遍历
def in_order(root):
    if root:
        in_order(root.lchild)
        print(root.data,end=' ')
        in_order(root.rchild)
in_order(root) #a b c d e g f

# 后序遍历
def post_order(root):
    if root:
        post_order(root.lchild)
        post_order(root.rchild)
        print(root.data,end=' ')
post_order(root) # b d c a f g e 

# 层次遍历
def level_order(root):
    queue = deque() #创建一个队列
    queue.append(root) # 加入根节点
    while len(queue) > 0: #只要队不空
        node = queue.popleft()  #出队最前面的那个
        print(node.data, end=' ') # 打印最前面的那个节点
        if node.lchild:
            queue.append(node.lchild)
        if node.rchild:
            queue.append(node.rchild)
level_order(root) # e a g c f b d