python算法(二)—栈、队列、链表、哈希

企业开发 2023-06-05 05:05:39 阅读次数: 0

文章目录

数据结构：指的是相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成。比如，列表、集合和字典等都是一种数据结构。 数据结构的分类

在这里插入图片描述

一、栈

栈：限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。

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

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 is_empty(self):
        return len(self.stack) == 0


def brace_match(s):
    match = {
    
    ')': '(', ']': '[', '}': '{'}
    stack = Stack()
    for ch in s:
        if ch in {
    
    '(', '[', '{'}:
            stack.push(ch)
        else:  # ch in {')',']','}'}
            if stack.is_empty():
                return False
            elif stack.get_top() == match[ch]:
                stack.pop()
            else:  # stack.get_top() != match[ch]
                return False
    if stack.is_empty():
        return True
    else:
        return False

s1 = '[]{[]{}()}[]'
s2 = '[)]}'
print(brace_match(s1))
print(brace_match(s2))

二、队列

1、单向队列(Queue)是一个数据集合，仅允许在列表的一端进行插入(队尾)，另一端进行删除(队首)，按先进先出的性质(First-in ,First-out)。
单向队列的实现方式——环形队列：当队尾指针front==Maxsize+1时，再前进一个位置就自动到0。
队首指针前进1：front=(front+1)%Maxsize
队尾指针前进1：rear=(rear+1)%Maxsize
对空条件：rear=front
队满条件：(rear+1)%Maxsize=front

class Queue:
    def __init__(self,size=100):
        self.queue=[0 for _ 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 filled")

    #出队
    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")



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

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

3、Python队列内置模块

from collections import deque
queue=deque()   #创建队列
queue.append(1) #队尾进队
queue.popleft() #队首出队
queue.appendleft(1)  #双向队列首进队
queue.pop() #双向队列队尾出队

如果队满则会自动出队

from collections import deque
queue=deque([1,2,3,4,5],5)
queue.append(6) 
print(queue.popleft())   # —>输出  2

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

给一个二维列表来表示迷宫（0表示通道，1表示围墙），给出算法求一条走出迷宫的路径。
在这里插入图片描述
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]
]

#（x,y）：初始位置，dirs表示上下左右移动的位置
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):#x1,y1初始位置；x2,y2终点位置
    stack=[]
    stack.append((x1,y1))
    while len(stack)>0:
        curNode = stack[-1]  # 当前的节点位置

        #若走到了终点
        if curNode[0]==x2 and curNode[1]==y2:
            for p in stack:
                print(p)
            return True

        # (x,y)向四个方向移动
        for dir in dirs:
            nextNode=dir(curNode[0],curNode[1])
            #判断下一个节点是否能走通
            if maze[nextNode[0]][nextNode[1]]==0:
                stack.append(nextNode)
                maze[nextNode[0]][nextNode[1]]=2    #用2标记已经走过
                break
        else:
            maze[nextNode[0]][nextNode[1]]=2
            stack.pop() #若走不通，则弹出此节点，以返回上一个节点

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


maze_path(1,1,8,8)

2、队列——广度优先搜索
用栈做深度搜索并不能保证路线是最短的，因此用队列来进行。
思路：从一个节点开始，寻找所有接下来能继续走的点，继续不断寻找，直到找到出口。使用队列存储当前正在考虑的点。
在这里插入图片描述
2进队，1进队——>3进队，2出队——>4，5进队，3出队——>6，7进队，4，5出队——>……
然后，将初始位置1下标记为-1；下一个位置2是由上一个位置带入的，其下标为0；……
在这里插入图片描述

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]
]

#（x,y）：初始位置，dirs表示上下左右移动的位置
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)
]
from collections import  deque

def print_r(path):
    curNode=path[-1]   #终点的位置
    realpath=[]     #真实路径
    while curNode[2]!=-1:
        realpath.append(curNode[0:2])
        curNode=path[curNode[2]]
    realpath.append(curNode[0:2])   #起点
    realpath.reverse()
    for node in realpath:
        print(node)

def maze_path_queue(x1,y1,x2,y2):
    queue=deque()
    queue.append((x1,y1,-1)) #将初始位置下标记作-1
    path=[]
    while len(queue)>0:
        curNode=queue.popleft() #当前节点的位置
        path.append(curNode)
        if curNode[0] == x2 and curNode[1] == y2:   #终点
            print_r(path)
            return True
        for dir in dirs:
            nextNode=dir(curNode[0],curNode[1])
            if maze[nextNode[0]][nextNode[1]]==0:
                queue.append((nextNode[0],nextNode[1],len(path)-1)) #后续可行节点进队，并记录有哪个节点带进来的
                maze[nextNode[0]][nextNode[1]]=2
    else:
        print("没有路")
        return False

maze_path_queue(1,1,8,8)

四、链表

链表是由一系列节点组成的元素集合。每个节点包含两部分，数据域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

print('a.item:',a.item)
print('a.next.item:',a.next.item)

输出：
a.item: 1
a.next.item: 2

1、创建链表
头插法：在头节点处插入，插入的节点将成为新的头节点
尾插法：在尾节点处插入，插入的节点将成为新的尾节点

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

def creat_linklist_head(li):    #头插法
    head=Node(li[0])
    for element in li[1:]:
        node=Node(element)
        node.next=head
        head=node
    return head

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

def print_linklist(lk):		#链表的遍历
    while lk:
        print(lk.item,end=',')
        lk=lk.next

lk1=creat_linklist_head([1,2,3])
print_linklist(lk1)  #输出3,2,1

lk2=creat_linklist_tail([1,2,3])
print_linklist(lk2) #输出1,2,3

2、节点的插入、删除
插入：4先与2相连，然后1与4相连
在这里插入图片描述
删除：1与2相连，再删除4在这里插入图片描述3、双链表每个节点有两个指针：一个指向后一个节点，另一个指向前一个节点。在这里插入图片描述

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

插入：
在这里插入图片描述
删除：
在这里插入图片描述
4、复杂度分析

顺序表（列表、数组） 链表
按元素值查找 O(n) O(n)
按下标查找 O(1) O(n)
在某元素后插入 O(n) O(1)
删除某元素 O(n) O(1)

五、哈希表

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

  • insert(key,value)：插入键值对(key,value)
  • get(key)：如果存在键为key的键值则返回其value，否则返回空值
  • delete(key)：删除键为key的键值对
    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 find(self, k):
        i = self.h(k)
        return self.T[i].find(k)

    def insert(self, k):
        i = self.h(k)
        if self.find(k):
            print("Duplicated Insert")
        else:
            self.T[i].append(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(3))

猜你喜欢

转载自blog.csdn.net/Ricardo2/article/details/119414385
今日推荐
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
周排行
浏览器对同一域名进行请求的最大并发连接数
React Hook之自定义Hook
【转】MyBatis缓存机制
-Java-泛型
自动化测试常用脚本-发送邮件
LeetCode#859: Buddy Strings
java、Python处理字符串
第二篇の博客
Hadoop伪分布式环境安装
SQL Server进阶（十一）临时表、表变量
每日归档
更多
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022