Python中的数据结构

 

#巧用Python列表特性实现特定数据结构

#栈实现
stack = []
stack.push(x)
stack.pop()
stack[-1]

#队列实现
from collections import deque
queue = deque()
#单向队列
queue.append(x)
queue.popleft()
#双向队列
queue.append(x)
queue.popleft()
queue.appendleft(x)
queue.pop()

#环形队列
#初始
dqueue = []
rear = 0
front = 0
#添加一个数据
front = (front + 1 ) % MaxSize
#一个数据出队
rear = (rear + 1 ) % MaxSize
#空队条件
rear == front
#满队条件
(rear + 1 ) % MaxSize == front

#巧用Python类特性实现特定数据结构

#链表实现
class Node(object):
def __init__(self,item=None):
  self.item = item
  self.next = None

def main():
  head = Node(1)
  b = Node(2)
  head.next = b

head -> b -> None

#head为链表首部,有无数据都可以
#遍历链表
def traversal(head):
  currNode = head
  while currNode is not None:
    print(currNode.item)
    currNode = currNode.next
#链表的插入、删除
#插入
#p.next = currNode.next
#currNode.next = p
#删除
#currNode.next = p
#currNode.next = currNode.next.next
#del p

#双向链表
class Node(object):
def __init__(self,item=None):
  self.item = itme
  self.next = None
  self.prev = None
#插入
#p.next = currNode.next
#currNode.next.prev = p
#p.prev = currNode
#currNode.next = p
#删除
#p = currNode.next
#currNode.next = p.next
#p.next.prev = currNode
#del p

#链表和列表的效率分析
#按元素查找时间复杂度都为O(n)
#按下标查找链表时间复杂度为O(n),列表为O(1)
#在某元素后插入数据链表时间复杂度为O(1),列表的时间复杂度为O(n)
#删除某元素链表时间复杂度为O(n),列表时间复杂度为O(1)

#散列表(Hash表)实现
#它是一种线性存储的表结构
#首先根据关键字k,进过某Hash函数,获得一个索引值
#然后将该关键字存储到索引值所在的位置

#这也是集合的存储原理

#对于字典也是类似的
#字典是对每一个key求索引值,索引值对应的位置存放相应的value

#问题一:
#索引值重复
#解决一:线性表每个位置采用链表存储,相同索引值得关键字,依次链接起来(拉链法
#解决二:通过哈希冲突函数得到新的地址(开放地址法)

#利用栈解决迷宫问题

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,1,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 mpath(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
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]] = -1 # 标记为已经走过,防止死循环
break
else:#四个方向都没找到
maze[curNode[0]][curNode[1]] = -1 # 死路一条,下次别走了
stack.pop() #回溯
print("没有路")
return False mpath(1,1,8,8)

#利用队列解决迷宫问题

from collections import  deque

mg = [
[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,1,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_p(path):
curNode = path[-1]
realpath = []
print('迷宫路径为:')
while curNode[2] != -1:
realpath.append(curNode[0:2])
curNode = path[curNode[2]]
realpath.append(curNode[0:2])
realpath.reverse()
print(realpath) def mgpath(x1, y1, x2, y2):
queue = deque()
path = []
queue.append((x1, y1, -1))
while len(queue) > 0:
curNode = queue.popleft()
path.append(curNode)
if curNode[0] == x2 and curNode[1] == y2:
#到达终点
print_p(path)
return True
for dir in dirs:
nextNode = dir(curNode[0], curNode[1])
if mg[nextNode[0]][nextNode[1]] == 0: # 找到下一个方块
queue.append((*nextNode, len(path) - 1))
mg[nextNode[0]][nextNode[1]] = -1 # 标记为已经走过
return False mgpath(1,1,8,8)

Python实现常用的数据结构的更多相关文章

  1. 第二章 python中重要的数据结构(下)

    二.元组(tuple):不可变序列 跟list一样,也是一种序列,唯一不同的是,元组元素不能被修改,通常用(, ,)表示元组,也可以不加括号. #创建元组 >>> 1,2,3 (1, ...

  2. Python实现常用排序算法

    Python实现常用排序算法 冒泡排序 思路: 它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完 ...

  3. 【转】python 历险记(四)— python 中常用的 json 操作

    [转]python 历险记(四)— python 中常用的 json 操作 目录 引言 基础知识 什么是 JSON? JSON 的语法 JSON 对象有哪些特点? JSON 数组有哪些特点? 什么是编 ...

  4. Python中的高级数据结构详解

    这篇文章主要介绍了Python中的高级数据结构详解,本文讲解了Collection.Array.Heapq.Bisect.Weakref.Copy以及Pprint这些数据结构的用法,需要的朋友可以参考 ...

  5. python学习笔记五——数据结构

    4 . python的数据结构 数据结构是用来存储数据的逻辑结构,合理使用数据结构才能编写出优秀的代码.python提供的几种内置数据结构——元组.列表.字典和序列.内置数据结构是Python语言的精 ...

  6. python 历险记(四)— python 中常用的 json 操作

    目录 引言 基础知识 什么是 JSON? JSON 的语法 JSON 对象有哪些特点? JSON 数组有哪些特点? 什么是编码和解码? 常用的 json 操作有哪些? json 操作需要什么库? 如何 ...

  7. Python中的高级数据结构(转)

    add by zhj: Python中的高级数据结构 数据结构 数据结构的概念很好理解,就是用来将数据组织在一起的结构.换句话说,数据结构是用来存储一系列关联数据的东西.在Python中有四种内建的数 ...

  8. python算法常用技巧与内置库

    python算法常用技巧与内置库 近些年随着python的越来越火,python也渐渐成为了很多程序员的喜爱.许多程序员已经开始使用python作为第一语言来刷题. 最近我在用python刷题的时候想 ...

  9. python数据分析03Python的数据结构、函数和文件

    我们会从Python最基础的数据结构开始:元组.列表.字典和集合.然后会讨论创建你自己的.可重复使用的Python函数.最后,会学习Python的文件对象,以及如何与本地硬盘交互. 3.1 数据结构和 ...

随机推荐

  1. AMDP + XSLX Workbench 报表开发模式

    本文介绍了我和同事通过使用AMDP + XSLX Workbench缩短报表开发周期.分离数据查询处理逻辑和前端展示工作的经验.欢迎讨论. 前言 最近接到了一套人力资源报表的开发需求,需要以EXCEL ...

  2. Zabbix的网络发现

      Zabbix的网络发现 Zabbix的网络发现功能,可以让我们发现网络中的主机或者服务,并在发现该设备后做出相应的操作; 它可以用HTTP.ICMP.SSH.LDAP.TCP.SNMP.Telne ...

  3. 好用的Google漏洞爬虫:Google Mass Explorer

    这是一款基于谷歌搜索引擎的自动化爬虫. 爬虫介绍 爬虫大体机制就是: 先进行一次谷歌搜索,将结果解析为特定格式,然后再提供给exp使用. 大家可以尝试使用–help来列出所有参数. 这个项目笔者会持续 ...

  4. Dagger2 使用全解析

    Dagger2 使用全解析 Dagger是一个注入工具,何为注入,我们要生产一批机器人,每个机器人都有一个控制器,我们可以在机器人内部 new 出一个控制器: class Robot { val co ...

  5. PLECS_直流电机基本系统模型

    1.模型图 2.模型仿真结果 (1)Step阶跃t=1s,R=20Ω,V_dc = 120V,那么此时 电源电压波形: 电机电枢电流波形: 电机电磁转矩: 电机转速波形: (2)其他参数不变将R=30 ...

  6. C预处理器和C库

    #define #include #undef #ifdef #else #endif #if #elif #else #endif 预处理宏: p463 _ _fun_ _是预定义标识符(函数作用域 ...

  7. 5、flask之信号和mateclass元类

    本篇导航: flask实例化参数 信号 metaclass元类解析 一.flask实例化参数 instance_path和instance_relative_config是配合来用的:这两个参数是用来 ...

  8. 共享表空间VS独立表空间

    基础概念:共享表空间 VS 独立表空间 [共享表空间] 又称为system tablespace系统表空间,a small set of data files (the ibdata files) . ...

  9. Sql Server 常用事务处理总结

    在数据库操作中,常用事务写法: 1. 通过 @@error 判断一批sql 执行完毕,是否有异常.  @@error 为系统变量,每次执行完 sql 都会返回一个数值,  0 表示 执行成功 ,非0 ...

  10. Java long类型和Long类型的那些事

    还记得最近做了一个项目使用的是Long类型作为主键Id坑死人了,对于我们来说Long类型一样是一个包装类型,类似String类型,使用==符号进行比较的时候有时候会出现问题,建议适应equal()方法 ...