数据结构

 数据结构基础

数据结构

　　定义：简单来说，数据结构就是设计数据以何种方式组织并存储在计算机中。比如：列表、集合与字典等都是一种数据结构。

　　PS:“程序=数据结构+算法”

　　列表：在其他编程语言中称为“数组”，是一种基本的数据结构类型。
　　　　关于：列表的存储问题！
数据结构的分类：
　　线性结构：数据结构中的元素存在一对一的相互关系
　　树结构：数据结构中的元素存在一对多的相互关系
　　图结构：数据结构中的元素存在多对多的相互关系


栈：
　　栈(Stack)是一个数据集合，可以理解为只能在一端进行插入或删除操作的列表。
　　栈的特点：后进先出（last-in, first-out）
　　栈的概念：
　　　　栈顶
　　　　栈底
　　栈的基本操作：
　　　　进栈（压栈）：push

　　　　出栈：pop
　　　　取栈顶：gettop

#利用python简单的实现栈操作
class Stack(object):
    def __init__(self):
        self.stack=[]
    def isEmpty(self):
        return self.stack==[]
    def push(self,item):
        self.stack.append(item)
    def pop(self):
        if self.isEmpty():
            raise IndexError,'pop from empty stack'
        return self.stack.pop()
    def peek(self):
        return self.stack[-1]
    def size(self):
        return len(self.stack)

栈的应用——括号匹配问题
括号匹配问题：给一个字符串，其中包含小括号、中括号、大括号，求该字符串中的括号是否匹配。
例如：
　　()()[]{}    匹配
　　([{()}])    匹配
　　[](    不匹配
　　[(])    不匹配

def Matching(exp="{[()]}"):
    stack = []
    for i in exp:
        if i in {'(','[','{'}:
            stack.append(i)
        if i == ')':
            if len(stack)>0 and stack[-1] == '(':
                stack.pop()
            else:
                return False
        if i == ']':
            if len(stack)>0 and stack[-1] == '[':
                stack.pop()
            else:
                return False
        if i == '}':
            if len(stack)>0 and stack[-1] == '{':
                stack.pop()
            else:
                return False
    if len(stack)==0:
        return True
    else:
        return False

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

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

 

队列实现：
　　使用方法：from collections import deque
　　创建队列：queue = deque(li)
　　进队：append
　　出队：popleft
　　双向队列队首进队：appendleft
　　双向队列队尾进队：pop

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

 环形队列：
　　　　改进方案：将列表首尾逻辑上连接起来。
　　　　环形队列：当队尾指针front == Maxsize + 1时，再前进一个位置就自动到0。
　　　　实现方式：求余数运算
　　　　队首指针前进1：front = (front + 1) % MaxSize
　　　　队尾指针前进1：rear = (rear + 1) % MaxSize
　　　　队空条件：rear == front
　　　　队满条件：(rear + 1) % MaxSize == front

---

 队列的内置模块：

使用方法：from collections import deque
    创建队列：queue = deque(li)
    进队：append
    出队：popleft
    双向队列队首进队：appendleft
    双向队列对尾出队：pop

 链表：

链表中的每一个元素都是一个对象，每个对象称之为一个节点，包含有数据域key和指向下一个节点的指针next。通过各个节点之间的相互连接，最终串联成一个链表。
节点定义：
 class Node(object):
    def __init__(self,item):
        self.item = item
        self.next = None

建立链表有两种方式（头插法和尾插法）：

链表可以有遍历操作：
链表节点的插入和删除：
1、插入
    p.next = curNode.next     #要插入的下一个为curNode的下一个，也就是3
    curNode.next = p          #curNode的下一个为p，也就是刚刚插入的那个，
2、删除
    p = curNode.next       #p为curNode的下一个节点
    curNode.next = curNode.next.next    #curNode的下一个节点=curNode.next.next（变相的赋值）
    del p    #最后删除中间那个碍眼的家伙

双向链表：

定义：双链表中的每个节点都有两个指针：一个指向后边的节点、一个指向前面的节点。
代码定义：
class Node(object):
    def __init__(self,item=None):
        self.item = item      #当前节点
        self.next = None     #下一个
        self.prior = None     #前一个

双链表节点的插入和删除（感觉很绕）
插入：
    p.next = curNode.next    #p的下一个=curNode的下一个
    curNode.next.prior = p    #curNode的下一个的前一个=p
    p.prior = curNode          #q的前一个就是curNode
    curNode.next = p            #之后curNode的下一个就是p
删除：
    p = curNode.next             #p是curNode的下一个
    curNode.next = p.next          #赋值   curNode的下一个就是p的下一个
    p.next.prior = curNode          #p的下一个的前一额就是curNode
    del p                            #删除p，赋值成功

链表-复杂度分析：
列表与链表：
    暗元素值查找
    按下表查找
    在某元素后插入
    删除某元素

哈希表：

哈希表（hash table，又称为散列表），是一种线性表的存储结构。哈希表有一个顺序表（也就是数组）和一个哈希函数组成（哈希函数就是加密算法，顺序表就是加密后的值）。
哈希函数h(k) 将元素k作为自变量，返回元素的存储下标。
简单的哈希函数：
    除法哈希：h(k) = k mod m   #对m取余
    乘法哈希：h(k) = floor(m(kA mod 1)) 0<A<1

假设有一个长度为7的数组，河西函数h(k) = K%7.元素集合{14,22,3,5}的存储方式如下图（制作图片链接https://visualgo.net/en）。

哈希冲突：
    由于哈希表的大小是有限的，而要存储的值得总数量是无线的，因此对于任何哈希函数，都会出现两个不同的元素映射到同一个位置上的情况，这种情况就叫做哈希冲突。
解决哈希冲突--开放寻址法：
    开放寻址法：如果哈希函数返回的位置已经有值，则可以向后探查新的位置来存储这个值。
        线性探查：如果位置i被占用，则探查i+1，i+2·····
        二次探查：如果位置i被占用，则探查i+1²，i-1²，i+2²···
        二度哈希：有n个哈希函数，当使用第一个哈希函数h1发生冲突时，则尝试使用h3，h3等
    拉链法：哈希表每个位置都链接一个链表，当冲突发生时，冲突的元素讲被加到该位置链表的最后（图示略）

哈希表在python中的应用

字典与集合都是通过哈希表来实现的
在python中的字典；
    ls = {"name":"username","password":"password"}
使用哈希表存储字典，通过哈希函数将字典的键映射为下标
在字典键值对数量不多的情况下，几乎不会发生类似于哈希冲突，此时查找一个元素的时间复杂度为O(1)

二叉树：

二叉树的链式存储：将二叉树的节点定义为一个对象，节点之间通过类似链表的链接方式来链接。
节点定义：
 class BiTreeNode(object):
    def __init__(self,data):
        self.data = data
        self.lchild = None      #左边的孩纸
        self.rchild = None     #右边的孩纸
二叉树的遍历方式：
    前序遍历：
    中序遍历：
    后序遍历：
    层次遍历：

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

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

root = e

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

#后续遍历
def post_order(root):
if root:
post_order(root.lchild)
post_order(root.rchild)
print(root.data, end='')

#层次遍历
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)

pre_order(root)
print("")
in_order(root)
print("")
post_order(root)
print("")
level_order(root)

遍历完之后比对他们的打印结果你会发现都是不同的

二叉搜索树：

二叉搜索树是一颗二叉树且满足性质：
设x是二叉树的一个节点。如果y是x左子树的一个节点，那么y.key<= x.key;
如果y是x右子树的一个节点，那么y.key>=x.key.
二叉搜索树的创建
二叉搜索树的遍历（采用中序序列遍历）
二叉搜索树的查询、插入、删除操作
ps：随机化的二叉搜索树，AVL树

AVL树：avl树是一个自平衡的二叉搜索树。

具有的性质：

        根的左右子树的高度之差的绝对值不能超过1

        根的左右子树都是平衡二叉树

AV领的实现方式：旋转（在我上边留的网站自己测试，很诡异，了解即可）：

B树（B-Tree）：B树是一颗自平衡的多路搜索树。常用于数据库的索引。

   

python中的位运算符：

位运算符要比乘除法更快，深得广大程序员的喜爱

数据结构-实例代码

栈的应用-迷宫问题

给一个二维列表，表示迷宫（0表示通道，1表示围墙），给出算法，求一条走出迷宫的路径。

from collections import deque
两种思路：基于堆栈、基于队列
基于堆栈：在一个迷宫节点(x,y)上，可以进行四个方向的探查：maze[x-1][y],maze[x+1][y],maze[x][y-1],maze[x][y+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,y+1),  #右
    lambda x,y:(x+1,y),  #下
    lambda x,y:(x,y-1),  #左
]


def solve_maze(x1, y1, x2, y2):
　　"""基于栈实现"""
    stack = []
    stack.append((x1,y1))
    maze[x1][y1] = 2
    while len(stack) > 0:   # 当栈不空循环
        cur_node = stack[-1]
        if cur_node == (x2,y2): #到达终点
            for p in stack:
                print(p)
            return True
        for dir in dirs:
            next_node = dir(*cur_node)
            if maze[next_node[0]][next_node[1]] == 0:   #找到一个能走的方向
                stack.append(next_node)
                maze[next_node[0]][next_node[1]] = 2  # 2表示已经走过的点
                break
        else: #如果一个方向也找不到
            stack.pop()
    else:
        print("无路可走")
        return False


def solve_maze2(x1,y1,x2,y2):
    """基于队列来实现"""
    queue = deque()
    path = []    # 记录出队之后的节点
    queue.append((x1,y1,-1))
    maze[x1][y1] = 2
    while len(queue) > 0:
        cur_node = queue.popleft()
        path.append(cur_node)
        if cur_node[0] == x2 and cur_node[1] == y2:  #到终点
            real_path = []
            x,y,i = path[-1]
            real_path.append((x,y))
            while i >= 0:
                node = path[i]
                real_path.append(node[0:2])
                i = node[2]
            real_path.reverse()
            for p in real_path:
                print(p)
            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 # 标记为已经走过
    else:
        print("无路可走")
        return False

solve_maze2(1,1,8,8)          #输入起点的位置和终点的位置

。。。。。。。。。。有时间更新