Day 75 数据结构

数据结构

数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成。 简单来说，数据结构就是设计数据以何种方式组织并存储在计算机中。 比如：列表、集合与字典等都是一种数据结构。 N.Wirth: “程序=数据结构+算法”。

数据结构的分类

数据结构按照其逻辑结构可分为线性结构、树结构、图结构

线性结构：数据结构中的元素存在一对一的相互关系

树结构：数据结构中的元素存在一对多的相互关系

图结构：数据结构中的元素存在多对多的相互关系

栈

使用一般的列表结构即可实现栈

进栈：li.append

出栈：li.pop

取栈顶：li[-1]

 

 

 

栈的应用——括号匹配问题

括号匹配问题：给一个字符串，其中包含小括号、中括号、大括号，求该字符串中的括号是否匹配。
例如：

()()[]{} 匹配

([{()}]) 匹配

[]( 不匹配

[(]) 不匹配

def match(s):
    match = {'}': '{', ']': '[', ')': '('}
    li = []
    for ch in s:
        if ch in {'{', '(', '['}:
            li.append(ch)
        else:  # ch in {'}',')',']'}
            if len(li) == 0:
                return False
            elif len(li) > 0 and li[-1] == match[ch]:
                li.pop()
            else:  # li[-1] not in match
                return False
    if len(li):
        return False
    else:
        return True


print(match('{[{()}]}'))

队列

队列(Queue)是一个数据集合，仅允许在列表的一端进行插入，另一端进行删除。

进行插入的一端称为队尾(rear)，插入动作称为进队或入队

进行删除的一端称为队头(front)，删除动作称为出队

队列的性质：先进先出(First-in, First-out)

 

class Queue:
    def __init__(self, size=100):
        self.size = size
        self.queue = [0 for _ in range(100)]
        self.rear = 0  # 队尾指针
        self.front = 0  # 队首指针

    def push(self, element):
        if not self.is_filled():
            self.rear = (self.rear + 1) % self.size
            self.queue[self.rear] = element
        else:
            raise ImportError('队列已满')

    def pop(self):
        if not self.is_empth():
            self.front = (self.front + 1) % self.size
            return self.queue[self.front]
        else:
            raise ImportError('队列已空')

    # 判断队空
    def is_empth(self):
        return self.rear == self.front

    # 判断队满
    def is_filled(self):
        return (self.rear + 1) % self.size == self.front



q = Queue(5)
for i in range(4):
    q.push(i)

print(q.is_filled())
print(q.pop())
print(q.pop())
print(q.pop())
print(q.pop())
print(q.push(15))
print(q.pop())

 

双向队列

双向队列的两端都支持进队和出队操作

双向队列的基本操作： 队首进队、队首出队、队尾进队、队尾出队

队列的实现

from collections import deque
q = deque([1,2,3,4,5],5) # 非空对列 长度为 5，长度大于 5 时，会自动八队首移出
q.append(7)         # 队尾进队
print(q.popleft())  # 队首出队

q.appendleft(1)     # 队首进队
print(q.pop())      # 队尾出对

# 读取文件中后 5 行数据
def tail(num):
    with open('./info.txt','r',encoding='utf-8')as f:
        q = deque(f,num)
        return q

for i in tail(5):
    print(i,end='')

 

队列的实现方式——环形队列

 

 

 

 栈和队列的应用——迷宫问题

 

栈——深度优先搜索

 

# 0 代表路，1 代表墙
maze = [
    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
    [1, 0, 0, 1, 0, 0, 0, 1, 0, 1],
    [1, 0, 0, 1, 0, 0, 0, 1, 0, 1],
    [1, 0, 0, 0, 0, 1, 1, 0, 0, 1],
    [1, 0, 1, 1, 1, 0, 0, 0, 0, 1],
    [1, 0, 0, 0, 1, 0, 0, 0, 0, 1],
    [1, 0, 1, 0, 0, 0, 1, 0, 0, 1],
    [1, 0, 1, 1, 1, 0, 1, 1, 0, 1],
    [1, 1, 0, 0, 0, 0, 0, 0, 0, 1],
    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
]

# 方向
dirs = [
    lambda x, y: (x + 1, y),
    lambda x, y: (x - 1, y),
    lambda x, y: (x, y + 1),
    lambda x, y: (x, y - 1),
]


def maze_path(x1, y1, x2, y2):
    stack = []
    stack.append((x1, y1))
    while len(stack) > 0:
        curCode = stack[-1]  # 当前节点
        if curCode[0] == x2 and curCode[1] == y2:
            # 走到了终点
            for p in stack:
                print(p)
            return True
        # 查找 4 个方向
        for dir in dirs:
            nextCode = dir(curCode[0], curCode[1])
            if maze[nextCode[0]][nextCode[1]] == 0:
                stack.append(nextCode)
                maze[nextCode[0]][nextCode[1]] = 2  # 表示已经走过了
                break
        else:
            maze[nextCode[0]][nextCode[1]] = 2
            stack.pop()

    else:
        print('没有路')
        return False

maze_path(1,1,8,8)

 

队列——广度优先搜索

 

from collections import deque

# 0 代表路，1 代表墙
maze = [
    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
    [1, 0, 0, 1, 0, 0, 0, 1, 0, 1],
    [1, 0, 0, 1, 0, 0, 0, 1, 0, 1],
    [1, 0, 0, 0, 0, 1, 1, 0, 0, 1],
    [1, 0, 1, 1, 1, 0, 0, 0, 0, 1],
    [1, 0, 0, 0, 1, 0, 0, 0, 0, 1],
    [1, 0, 1, 0, 0, 0, 1, 0, 0, 1],
    [1, 0, 1, 1, 1, 0, 1, 1, 0, 1],
    [1, 1, 0, 0, 0, 0, 0, 0, 0, 1],
    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
]

# 方向
dirs = [
    lambda x, y: (x + 1, y),
    lambda x, y: (x - 1, y),
    lambda x, y: (x, y + 1),
    lambda x, y: (x, y - 1),
]

def print_r(path):
    real_path = []
    i = len(path) - 1
    while i >= 0:
        real_path.append(path[i][0:2])
        i = path[i][2]
    real_path.reverse()
    for node in real_path:
        print(node)


def maze_path_duque(x1, y1, x2, y2):
    queue = deque()
    path = []
    queue.append((x1,y1,-1))    # 设置起点坐标
    while len(queue) > 0:        # 当队列不为空循环
        cur_node = queue.popleft()
        path.append(cur_node)
        if cur_node[0] == x2 and cur_node[1] == y2:
            print_r(path)     # 到达终点 打印坐标
            return True

        for dir in dirs:
            next_node = dir(cur_node[0],cur_node[1])
            if maze[next_node[0]][next_node[1]] == 0:
                queue.append((next_node[0],next_node[1],len(path) - 1))
                maze[next_node[0]][next_node[1]] = 2  # 走过的路径

    return False

maze_path_duque(1,1,8,8)

链表

 

 

 

创建与遍历链表

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


# a = Node(1)
# b = Node(2)
# a.next = b
# print(a.next.item)

# 头插法
def create_linklist_head(li):
    head = Node(li[0])      # 创建空列表，设置头节点
    for val in li[1:]:
        node = Node(val)
        node.next = head
        head = node
    return head

# 尾插法
def create_linklist_tail(li):
    head = Node(li[0])
    tail = head
    for val in li[1:]:
        node = Node(val)
        tail.next = node
        tail = node
    return head


def look(lk):
    while lk:
        print(lk.item,end=',')
        lk = lk.next

# lk_head = create_linklist_head([1,2,3,4,5])
lk_tail = create_linklist_tail([1,2,3,4,5])
print(look(lk_tail))

链表的插入和删除

 

 

 

 

 

 

双链表

 

 

双链表的插入与删除

 

 

 

 

 

 

链表在插入和删除的操作上明显快于顺序表

链表的内存可以更灵活的分配，试利用链表重新实现栈和队列

链表这种链式存储的数据结构对树和图的结构有很大的启发性

 

哈希表

哈希表一个通过哈希函数来计算数据存 储位置的数据结构，通常支持如下操作：

insert(key, value)：插入键值对

(key,value) get(key)：如果存在键为key的键值对则返回其value，否则返回空值

delete(key)：删除键为key的键值对

直接寻址表

 

 

哈希

 

 

 

 

哈希冲突

 

 

 

 

 

 

 

 

 哈希表——常见哈希函数

除法哈希法： h(k) = k % m

乘法哈希法： h(k) = floor(m*(A*key%1))

全域哈希法： ha,b(k) = ((a*key + b) mod p) mod m a,b=1,2,...,p-1

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

    class LinkListIterator:
        def __init__(self, node):
            self.node = node

        def __next__(self):
            if self.node:
                cur_node = self.node
                self.node = cur_node.next
                return cur_node.item
            else:
                raise StopIteration

        def __iter__(self):
            return self

    def __init__(self, iterable=None):
        self.head = None
        self.tail = None
        if iterable:
            self.extend(iterable)

    def append(self, obj):
        s = LinkList.Node(obj)
        if not self.head:
            self.head = s
            self.tail = s
        else:
            self.tail.next = s
            self.tail = s

    def extend(self, iterable):
        for obj in iterable:
            self.append(obj)

    def find(self, obj):
        for n in self:
            if n == obj:
                return True
        else:
            return False

    def __iter__(self):
        return self.LinkListIterator(self.head)

    def __repr__(self):
        return "<<"+", ".join(map(str, self))+">>"

# 类似于集合的结构
class HashTable:
    def __init__(self, size=101):
        self.size = size
        self.T = [LinkList() for i in range(self.size)]

    def h(self, k):
        return k % self.size

    def insert(self, k):
        i = self.h(k)
        if self.find(k):
            print("Duplicated Insert.")
        else:
            self.T[i].append(k)

    def find(self, k):
        i = self.h(k)
        return self.T[i].find(k)


ht = HashTable()

ht.insert(0)
ht.insert(1)
ht.insert(3)
ht.insert(102)
ht.insert(508)

#print(",".join(map(str, ht.T)))
print(ht.find(203))

哈希表的应用——集合与字典

字典与集合都是通过哈希表来实现的。

a = {'name': 'Alex', 'age': 18, 'gender': 'Man'}

使用哈希表存储字典，通过哈希函数将字典的键映射为下标。假设h('name') = 3, h('age') = 1, h('gender') = 4，则哈希表存储为[None, 18, None, 'Alex', 'Man']

如果发生哈希冲突，则通过拉链法或开发寻址法解决

 

Python对字典的关键字有什么要求？如何使一个自定义的类的对象成为字典的键？

Python对集合中的元素有什么要求？如何利用集合对大量的对象去重？

 

树的实例：模拟文件系统

class Node:
    def __init__(self, name, type='dir'):
        self.name = name
        self.type = type   #"dir" or "file"
        self.children = []
        self.parent = None
        # 链式存储

    def __repr__(self):
        return self.name


class FileSystemTree:
    def __init__(self):
        self.root = Node("/")
        self.now = self.root

    def mkdir(self, name):
        # name 以 / 结尾
        if name[-1] != "/":
            name += "/"
        node = Node(name)
        self.now.children.append(node)
        node.parent = self.now

    def ls(self):
        return self.now.children

    def cd(self, name):
        # "/var/python/"
        if name[-1] != "/":
            name += "/"
        if name == "../":
            self.now = self.now.parent
            return
        for child in self.now.children:
            if child.name == name:
                self.now = child
                return
        raise ValueError("invalid dir")



tree = FileSystemTree()
tree.mkdir("var/")
tree.mkdir("bin/")
tree.mkdir("usr/")

tree.cd("bin/")
tree.mkdir("python/")

tree.cd("../")

print(tree.ls())

 

二叉树

二叉树的链式存储：将二叉树的节点定义为一个对象，节点之间通过类似链表的链接方式来连接。

二叉树遍历

from collections import deque

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')

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

# print(root.rchild.rchild.data)


# 前序遍历
def front_order(root):
    if root:
        print(root.data,end=',')
        front_order(root.lchild)
        front_order(root.rchild)
# front_order(root)

# 中序遍历
def middle_order(root):
    if root:
        middle_order(root.lchild)
        print(root.data,end=',')
        middle_order(root.rchild)

# middle_order(root)

# 后序遍历
def back_order(root):
    if root:
        middle_order(root.lchild)
        print(root.data, end=',')
        middle_order(root.rchild)

# middle_order(root)

# 层级遍历
def level_order(root):
    qu = deque()
    qu.append(root)
    while len(qu)>0:
        node = qu.popleft()
        print(node.data,end=',')
        if node.lchild:
            qu.append(node.lchild)
        if node.rchild:
            qu.append(node.rchild)


level_order(root)

 

二叉树：插入、查询、删除

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

import random

class BiTreeNode:
    def __init__(self, data):
        self.data = data
        self.lchild = None   # 左孩子
        self.rchild = None  # 右孩子
        self.parent = None

class BST:
    def __init__(self, li=None):
        self.root = None
        if li:
            for val in li:
                self.insert_no_rec(val)

    def insert(self, node, val):
        if not node:
            node = BiTreeNode(val)
        elif val < node.data:
            node.lchild = self.insert(node.lchild, val)
            node.lchild.parent = node
        elif val > node.data:
            node.rchild = self.insert(node.rchild, val)
            node.rchild.parent = node
        return node

    def insert_no_rec(self, val):
        p = self.root
        if not p:               # 空树
            self.root = BiTreeNode(val)
            return
        while True:
            if val < p.data:
                if p.lchild:
                    p = p.lchild
                else:           # 左孩子不存在
                    p.lchild = BiTreeNode(val)
                    p.lchild.parent = p
                    return
            elif val > p.data:
                if p.rchild:
                    p = p.rchild
                else:
                    p.rchild = BiTreeNode(val)
                    p.rchild.parent = p
                    return
            else:
                return

    def query(self, node, val):
        if not node:
            return None
        if node.data < val:
            return self.query(node.rchild, val)
        elif node.data > val:
            return self.query(node.lchild, val)
        else:
            return node

    def query_no_rec(self, val):
        p = self.root
        while p:
            if p.data < val:
                p = p.rchild
            elif p.data > val:
                p = p.lchild
            else:
                return p
        return None

    def pre_order(self, root):
        if root:
            print(root.data, end=',')
            self.pre_order(root.lchild)
            self.pre_order(root.rchild)

    def in_order(self, root):
        if root:
            self.in_order(root.lchild)
            print(root.data, end=',')
            self.in_order(root.rchild)

    def post_order(self, root):
        if root:
            self.post_order(root.lchild)
            self.post_order(root.rchild)
            print(root.data, end=',')


    def __remove_node_1(self, node):
        # 情况1：node是叶子节点
        if not node.parent:
            self.root = None
        if node == node.parent.lchild:  #node是它父亲的左孩子
            node.parent.lchild = None
        else:   #右孩子
            node.parent.rchild = None

    def __remove_node_21(self, node):
        # 情况2.1：node只有一个左孩子
        if not node.parent: # 根节点
            self.root = node.lchild
            node.lchild.parent = None
        elif node == node.parent.lchild:
            node.parent.lchild = node.lchild
            node.lchild.parent = node.parent
        else:
            node.parent.rchild = node.lchild
            node.lchild.parent = node.parent

    def __remove_node_22(self, node):
        # 情况2.2：node只有一个右孩子
        if not node.parent:
            self.root = node.rchild
        elif node == node.parent.lchild:
            node.parent.lchild = node.rchild
            node.rchild.parent = node.parent
        else:
            node.parent.rchild = node.rchild
            node.rchild.parent = node.parent


    def delete(self, val):
        if self.root:   # 不是空树
            node = self.query_no_rec(val)
            if not node: # 不存在
                return False
            if not node.lchild and not node.rchild: #1. 叶子节点
                self.__remove_node_1(node)
            elif not node.rchild:       # 2.1 只有一个左孩子
                self.__remove_node_21(node)
            elif not node.lchild:       # 2.2 只有一个右孩子
                self.__remove_node_22(node)
            else:   # 3. 两个孩子都有
                min_node = node.rchild
                while min_node.lchild:
                    min_node = min_node.lchild
                node.data = min_node.data
                # 删除min_node
                if min_node.rchild:
                    self.__remove_node_22(min_node)
                else:
                    self.__remove_node_1(min_node)




#
#
# tree = BST([1,4,2,5,3,8,6,9,7])
# tree.in_order(tree.root)
# print("")
#
# tree.delete(4)
# tree.delete(1)
# tree.delete(8)
# tree.in_order(tree.root)

 

AVL树

 

 

 

AVL树——插入

插入一个节点可能会破坏AVL树的平衡，可以通过旋转操作来进行修正。

插入一个节点后，只有从插入节点到根节点的路径上的节点的平衡可能被改变。我们需要找出第一个破坏了平衡条件的节点，称之为K。K的两颗子树的高度差2。

不平衡的出现可能有4种情况

AVL插入——右旋

 

 

 

AVL插入——左旋

AVL插入——右旋-左旋

 

 

AVL插入——左旋-右旋

 

 

 二叉搜索树扩展应用——B树

B树(B-Tree)：B树是一棵自平衡的多路搜索树。常用于数据库的索引。