数据结构作为计算机基础的必修内容,也是很多大型互联网企业面试的必考题。可想而知,它在计算机领域的重要性。

然而很多计算机专业的同学,都仅仅是了解数据结构的相关理论,却无法用代码实现各种数据结构。

今日整理了一份常见数据结构的 Python 实现,希望大家能够参考代码,亲自动手通过代码实现各种数据结构,以巩固知识加深理解。

以下内容整理于《Python 实现各种常用算法》

  1. class Stack(object):
  2. def __init__(self, limit=10):
  3. self.stack = [] #存放元素
  4. self.limit = limit #栈容量极限
  5. def push(self, data): #判断栈是否溢出
  6. if len(self.stack) >= self.limit:
  7. print('StackOverflowError')
  8. pass
  9. self.stack.append(data)
  10. def pop(self):
  11. if self.stack:
  12. return self.stack.pop()
  13. else:
  14. raise IndexError('pop from an empty stack') #空栈不能被弹出
  15. def peek(self): #查看堆栈的最上面的元素
  16. if self.stack:
  17. return self.stack[-1]
  18. def is_empty(self): #判断栈是否为空
  19. return not bool(self.stack)
  20. def size(self): #返回栈的大小
  21. return len(self.stack)

单链表

  1. class Node:
  2. def __init__(self, data):
  3. self.data = data
  4. self.next = None
  5. class Linked_List:
  6. def __init__(self):
  7. self.head = None
  8. def initlist(self,data_list): #链表初始化函数
  9. self.head=Node(data_list[0]) #创建头结点
  10. temp=self.head
  11. for i in data_list[1:]: #逐个为 data 内的数据创建结点, 建立链表
  12. node=Node(i)
  13. temp.next=node
  14. temp=temp.next
  15. def is_empty(self): #判断链表是否为空
  16. if self.head.next==None:
  17. print("Linked_list is empty")
  18. return True
  19. else:
  20. return False
  21. def get_length(self): #获取链表的长度
  22. temp=self.head #临时变量指向队列头部
  23. length=0 #计算链表的长度变量
  24. while temp!=None:
  25. length=length+1
  26. temp=temp.next
  27. return length #返回链表的长度
  28. def insert(self,key,value): #链表插入数据函数
  29. if key<0 or key>self.get_length()-1:
  30. print("insert error")
  31. temp=self.head
  32. i=0
  33. while i<=key: #遍历找到索引值为 key 的结点后, 在其后面插入结点
  34. pre=temp
  35. temp=temp.next
  36. i=i+1
  37. node=Node(value)
  38. pre.next=node
  39. node.next=temp
  40. def print_list(self): #遍历链表,并将元素依次打印出来
  41. print("linked_list:")
  42. temp=self.head
  43. new_list=[]
  44. while temp is not None:
  45. new_list.append(temp.data)
  46. temp=temp.next
  47. print(new_list)
  48. def remove(self,key): #链表删除数据函数
  49. if key<0 or key>self.get_length()-1:
  50. print("insert error")
  51. i=0
  52. temp=self.head
  53. while temp !=None: #遍历找到索引值为 key 的结点
  54. pre=temp
  55. temp=temp.next
  56. i=i+1
  57. if i==key:
  58. pre.next=temp.next
  59. temp=None
  60. return True
  61. pre.next=None
  62. def reverse(self): #将链表反转
  63. prev = None
  64. current = self.head
  65. while current:
  66. next_node = current.next
  67. current.next = prev
  68. prev = current
  69. current = next_node
  70. self.head = prev

双链表

  1. class Node(object):
  2. # 双向链表节点
  3. def __init__(self, item):
  4. self.item = item
  5. self.next = None
  6. self.prev = None
  7. class DLinkList(object):
  8. # 双向链表
  9. def __init__(self):
  10. self._head = None
  11. def is_empty(self):
  12. # 判断链表是否为空
  13. return self._head == None
  14. def get_length(self):
  15. # 返回链表的长度
  16. cur = self._head
  17. count = 0
  18. while cur != None:
  19. count=count+1
  20. cur = cur.next
  21. return count
  22. def travel(self):
  23. # 遍历链表
  24. cur = self._head
  25. while cur != None:
  26. print(cur.item)
  27. cur = cur.next
  28. print("")
  29. def add(self, item):
  30. # 头部插入元素
  31. node = Node(item)
  32. if self.is_empty():
  33. # 如果是空链表,将_head指向node
  34. self._head = node
  35. else:
  36. # 将node的next指向_head的头节点
  37. node.next = self._head
  38. # 将_head的头节点的prev指向node
  39. self._head.prev = node
  40. # 将_head 指向node
  41. self._head = node
  42. def append(self, item):
  43. # 尾部插入元素
  44. node = Node(item)
  45. if self.is_empty():
  46. # 如果是空链表,将_head指向node
  47. self._head = node
  48. else:
  49. # 移动到链表尾部
  50. cur = self._head
  51. while cur.next != None:
  52. cur = cur.next
  53. # 将尾节点cur的next指向node
  54. cur.next = node
  55. # 将node的prev指向cur
  56. node.prev = cur
  57. def search(self, item):
  58. # 查找元素是否存在
  59. cur = self._head
  60. while cur != None:
  61. if cur.item == item:
  62. return True
  63. cur = cur.next
  64. return False
  65. def insert(self, pos, item):
  66. # 在指定位置添加节点
  67. if pos <= 0:
  68. self.add(item)
  69. elif pos > (self.length()-1):
  70. self.append(item)
  71. else:
  72. node = Node(item)
  73. cur = self._head
  74. count = 0
  75. # 移动到指定位置的前一个位置
  76. while count < (pos-1):
  77. count += 1
  78. cur = cur.next
  79. # 将node的prev指向cur
  80. node.prev = cur
  81. # 将node的next指向cur的下一个节点
  82. node.next = cur.next
  83. # 将cur的下一个节点的prev指向node
  84. cur.next.prev = node
  85. # 将cur的next指向node
  86. cur.next = node
  87. def remove(self, item):
  88. # 删除元素
  89. if self.is_empty():
  90. return
  91. else:
  92. cur = self._head
  93. if cur.item == item:
  94. # 如果首节点的元素即是要删除的元素
  95. if cur.next == None:
  96. # 如果链表只有这一个节点
  97. self._head = None
  98. else:
  99. # 将第二个节点的prev设置为None
  100. cur.next.prev = None
  101. # 将_head指向第二个节点
  102. self._head = cur.next
  103. return
  104. while cur != None:
  105. if cur.item == item:
  106. # 将cur的前一个节点的next指向cur的后一个节点
  107. cur.prev.next = cur.next
  108. # 将cur的后一个节点的prev指向cur的前一个节点
  109. cur.next.prev = cur.prev
  110. break
  111. cur = cur.next

队列(链表形式实现)

  1. class Node(object):
  2. def __init__(self,elem,next=None):
  3. self.elem = elem #表示对应的元素值
  4. self.next=next #表示下一个链接的链点
  5. class Queue(object):
  6. def __init__(self):
  7. self.head = None #头部链点为 None
  8. self.rear = None #尾部链点为 None
  9. def is_empty(self):
  10. return self.head is None #判断队列是否为空
  11. def enqueue(self, elem):
  12. p = Node(elem) #初始化一个新的点
  13. if self.is_empty():
  14. self.head = p #队列头部为新的链点
  15. self.rear = p #队列尾部为新的链点
  16. else:
  17. self.rear.next = p #队列尾部的后继是这个新的点
  18. self.rear =p #然后让队列尾部指针指向这个新的点
  19. def dequeue(self):
  20. if self.is_empty(): #判断队列是否为空
  21. print('Queue_is_empty') #若队列为空,则退出 dequeue 操作
  22. else:
  23. result = self.head.elem #result为队列头部元素
  24. self.head = self.head.next #改变队列头部指针位置
  25. return result #返回队列头部元素
  26. def peek(self):
  27. if self.is_empty(): #判断队列是否为空
  28. print('NOT_FOUND') #为空则返回 NOT_FOUND
  29. else:
  30. return self.head.elem #返回队列头部元素
  31. def print_queue(self):
  32. print("queue:")
  33. temp=self.head
  34. myqueue=[] #暂时存放队列数据
  35. while temp is not None:
  36. myqueue.append(temp.elem)
  37. temp=temp.next
  38. print(myqueue)

队列(数组形式实现)

  1. class Queue():
  2. def __init__(self):
  3. self.entries = [] #表示队列内的参数
  4. self.length = 0 #表示队列的长度
  5. self.front=0 #表示队列头部位置
  6. def enqueue(self, item):
  7. self.entries.append(item) #添加元素到队列里面
  8. self.length = self.length + 1 #队列长度增加 1
  9. def dequeue(self):
  10. self.length = self.length - 1 #队列的长度减少 1
  11. dequeued = self.entries[self.front] #队首元素为dequeued
  12. self.front-=1 #队首的位置减少1
  13. self.entries = self.entries[self.front:] #队列的元素更新为退队之后的队列
  14. return dequeued
  15. def peek(self):
  16. return self.entries[0] #直接返回队列的队首元素

二叉树

  1. class Node(object):
  2. def __init__(self,item):
  3. self.item=item #表示对应的元素
  4. self.left=None #表示左节点
  5. self.right=None #表示右节点
  6. def __str__(self):
  7. return str(self.item) #print 一个 Node 类时会打印 __str__ 的返回值
  8. class Tree(object):
  9. def __init__(self):
  10. self.root=Node('root') #根节点定义为 root 永不删除,作为哨兵使用。
  11. def add(self,item):
  12. node = Node(item)
  13. if self.root is None: #如果二叉树为空,那么生成的二叉树最终为新插入树的点
  14. self.root = node
  15. else:
  16. q = [self.root] # 将q列表,添加二叉树的根节点
  17. while True:
  18. pop_node = q.pop(0)
  19. if pop_node.left is None: #左子树为空则将点添加到左子树
  20. pop_node.left = node
  21. return
  22. elif pop_node.right is None: #右子树为空则将点添加到右子树
  23. pop_node.right = node
  24. return
  25. else:
  26. q.append(pop_node.left)
  27. q.append(pop_node.right)
  28. def get_parent(self, item):
  29. if self.root.item == item:
  30. return None # 根节点没有父节点
  31. tmp = [self.root] # 将tmp列表,添加二叉树的根节点
  32. while tmp:
  33. pop_node = tmp.pop(0)
  34. if pop_node.left and pop_node.left.item == item: #某点的左子树为寻找的点
  35. return pop_node #返回某点,即为寻找点的父节点
  36. if pop_node.right and pop_node.right.item == item: #某点的右子树为寻找的点
  37. return pop_node #返回某点,即为寻找点的父节点
  38. if pop_node.left is not None: #添加tmp 元素
  39. tmp.append(pop_node.left)
  40. if pop_node.right is not None:
  41. tmp.append(pop_node.right)
  42. return None
  43. def delete(self, item):
  44. if self.root is None: # 如果根为空,就什么也不做
  45. return False
  46. parent = self.get_parent(item)
  47. if parent:
  48. del_node = parent.left if parent.left.item == item else parent.right # 待删除节点
  49. if del_node.left is None:
  50. if parent.left.item == item:
  51. parent.left = del_node.right
  52. else:
  53. parent.right = del_node.right
  54. del del_node
  55. return True
  56. elif del_node.right is None:
  57. if parent.left.item == item:
  58. parent.left = del_node.left
  59. else:
  60. parent.right = del_node.left
  61. del del_node
  62. return True
  63. else: # 左右子树都不为空
  64. tmp_pre = del_node
  65. tmp_next = del_node.right
  66. if tmp_next.left is None:
  67. # 替代
  68. tmp_pre.right = tmp_next.right
  69. tmp_next.left = del_node.left
  70. tmp_next.right = del_node.right
  71. else:
  72. while tmp_next.left: # 让tmp指向右子树的最后一个叶子
  73. tmp_pre = tmp_next
  74. tmp_next = tmp_next.left
  75. # 替代
  76. tmp_pre.left = tmp_next.right
  77. tmp_next.left = del_node.left
  78. tmp_next.right = del_node.right
  79. if parent.left.item == item:
  80. parent.left = tmp_next
  81. else:
  82. parent.right = tmp_next
  83. del del_node
  84. return True
  85. else:
  86. return False

字典树

  1. class TrieNode:
  2. def __init__(self):
  3. self.nodes = dict() # 构建字典
  4. self.is_leaf = False
  5. def insert(self, word: str):
  6. curr = self
  7. for char in word:
  8. if char not in curr.nodes:
  9. curr.nodes[char] = TrieNode()
  10. curr = curr.nodes[char]
  11. curr.is_leaf = True
  12. def insert_many(self, words: [str]):
  13. for word in words:
  14. self.insert(word)
  15. def search(self, word: str):
  16. curr = self
  17. for char in word:
  18. if char not in curr.nodes:
  19. return False
  20. curr = curr.nodes[char]
  21. return curr.is_leaf

  1. class heap(object):
  2. def __init__(self):
  3. #初始化一个空堆,使用数组来在存放堆元素,节省存储
  4. self.data_list = []
  5. def get_parent_index(self,index):
  6. #返回父节点的下标
  7. if index == 0 or index > len(self.data_list) -1:
  8. return None
  9. else:
  10. return (index -1) >> 1
  11. def swap(self,index_a,index_b):
  12. #交换数组中的两个元素
  13. self.data_list[index_a],self.data_list[index_b] = self.data_list[index_b],self.data_list[index_a]
  14. def insert(self,data):
  15. #先把元素放在最后,然后从后往前依次堆化
  16. #这里以大顶堆为例,如果插入元素比父节点大,则交换,直到最后
  17. self.data_list.append(data)
  18. index = len(self.data_list) -1
  19. parent = self.get_parent_index(index)
  20. #循环,直到该元素成为堆顶,或小于父节点(对于大顶堆)
  21. while parent is not None and self.data_list[parent] < self.data_list[index]:
  22. #交换操作
  23. self.swap(parent,index)
  24. index = parent
  25. parent = self.get_parent_index(parent)
  26. def removeMax(self):
  27. #删除堆顶元素,然后将最后一个元素放在堆顶,再从上往下依次堆化
  28. remove_data = self.data_list[0]
  29. self.data_list[0] = self.data_list[-1]
  30. del self.data_list[-1]
  31. #堆化
  32. self.heapify(0)
  33. return remove_data
  34. def heapify(self,index):
  35. #从上往下堆化,从index 开始堆化操作 (大顶堆)
  36. total_index = len(self.data_list) -1
  37. while True:
  38. maxvalue_index = index
  39. if 2*index +1 <= total_index and self.data_list[2*index +1] > self.data_list[maxvalue_index]:
  40. maxvalue_index = 2*index +1
  41. if 2*index +2 <= total_index and self.data_list[2*index +2] > self.data_list[maxvalue_index]:
  42. maxvalue_index = 2*index +2
  43. if maxvalue_index == index:
  44. break
  45. self.swap(index,maxvalue_index)
  46. index = maxvalue_index

常见数据结构的 Python 实现(建议收藏)的更多相关文章

  1. 转 Python常见数据结构整理

    http://www.cnblogs.com/jeffwongishandsome/archive/2012/08/05/2623660.html Python常见数据结构整理 Python中常见的数 ...

  2. Python 100个样例代码【爆肝整理 建议收藏】

    本教程包括 62 个基础样例,12 个核心样例,26 个习惯用法.如果觉得还不错,欢迎转发.留言. 一. Python 基础 62 例 1 十转二 将十进制转换为二进制: >>> b ...

  3. 细说Python的lambda函数用法,建议收藏

    细说Python的lambda函数用法,建议收藏 在Python中有两种函数,一种是def定义的函数,另一种是lambda函数,也就是大家常说的匿名函数.今天我就和大家聊聊lambda函数,在Pyth ...

  4. (转)python资料汇总(建议收藏)零基础必看

    摘要:没料到在悟空问答的回答大受欢迎,为方便朋友,重新整理汇总,内容包括长期必备.入门教程.练手项目.学习视频. 一.长期必备. 1. StackOverflow,是疑难解答.bug排除必备网站,任何 ...

  5. 解密国内BAT等大厂前端技术体系-美团点评之下篇(长文建议收藏)

    引言 在上篇中,我已经介绍了美团点评的业务情况.大前端的技术体系,其中大前端的技术全景图如下: 上篇重点介绍了工程化和代码质量的部分,工程化涵盖了客户端持续集成平台-MCI.全端监控平台-CAT.移动 ...

  6. 【Python五篇慢慢弹】数据结构看python

    数据结构看python 作者:白宁超 2016年10月9日14:04:47 摘要:继<快速上手学python>一文之后,笔者又将python官方文档认真学习下.官方给出的pythondoc ...

  7. [py]软件编程知识骨架+py常见数据结构

    认识算法的重要性 - 遇到问题? 学完语言,接到需求,没思路? 1.学会了语言,能读懂别人的代码, 但是自己没解决问题的能力,不能够把实际问题转换为代码,自己写出来.(这是只是学会一门语言的后果),不 ...

  8. unity_数据结构(常见数据结构及适用场景)

    常见的数据结构: 1.Array: 最简单的数据结构 特点:数组存储在连续的内存上.数组的内容都是相同类型.数组可以直接通过下标访问.优点:由于是在连续内存上存储的,所以它的索引速度非常快,访问一个元 ...

  9. 解密国内BAT等大厂前端技术体系-携程篇(长文建议收藏)

    1 引言 为了了解当前前端的发展趋势,让我们从国内各大互联网大厂开始,了解他们的最新动态和未来规划.这是解密大厂前端技术体系的第四篇,前三篇已经讲述了阿里.腾讯.百度在前端技术这几年的技术发展. 这一 ...

随机推荐

  1. Python原生调试工具pdb实践小结

    使用python -m pdb xxx.py进入单步调试模式,默认会在脚本的第一行可执行命令处停止.此时,通过 b function设置之后的函数断点会提示出错,从出错异常栈中可以看出,pdb是将fu ...

  2. python |elasticsearchs操作es的例子

    from elasticsearch import Elasticsearch import json import time es = Elasticsearch(['es地址:9200'],ign ...

  3. SpringMVC返回值响应

    1.响应数据和结果视图 1.1 搭建环境 New Module -> Module SDK 1.8 -> Create from archetype -> maven-archety ...

  4. [转]解决 gem install 安装失败

    链接地址:https://blog.csdn.net/weixin_42414461/article/details/85337465

  5. VUE 同一页面路由参数变化,视图不刷新的解决方案

    1.监听路由处理 watch: { $route(to, from) { // 逻辑 // 重新调用数据接口 } }, 2.beforeRouteUpdate导航守卫 路由更新时触发 beforeRo ...

  6. spring boot使用WebClient调用其他系统提供的HTTP服务

    WebClient的请求模式属于异步非阻塞,能够以少量固定的线程处理高并发的HTTP请求 WebClient是Spring WebFlux模块提供的一个非阻塞的基于响应式编程的进行Http请求的客户端 ...

  7. Ubuntu下安装与卸载opencv模块

    opencv安装 因工程需要,想在python中调用opencv import cv2 现在记录一下如何在Linux系统(ubutun)下安装该模块: 参考了一篇博客:http://blog.csdn ...

  8. 远程登录Linux系统(使用xshell),远程上传加载文件(使用Xftp)

    一.Xshell(远程登录Linux系统) 1.安装xshell 自己百度找安装包 2.连接登录 1.连接前提 需要Linux开启一个sshd的服务,监听22号端口,一般默认是开启的 查看是否开启: ...

  9. Python中的高性能容器--collections

    集合模块 相对于 Python 中内置的称为链表.集合.字典和元组的默认容器类型来说,集合模块( collection module )提供了高性能的备选方案( alternative ). 简单地看 ...

  10. golang(三)

    map(声明.初始化和 make) 1. 概念2.map 容量3. 用切片作为 map 的值 概念 map 是引用类型,可以使用如下声明: var map1 map[keytype]valuetype ...