数据结构——链表&双链表的python实现

ゞ 浴缸里的玫瑰 2023-02-14 02:42 58阅读 0赞

链表的python实现

    • 单链表的实现
    • 双链表的实现

在这里插入图片描述

单链表的实现

  1. #定义单链表节点类
  2. class Node(object):
  3. def __init__(self,value=None,next=None):
  4. self.value = value
  5. self.next = next
  6. #单链表结构类
  7. class LinkedList(object):
  8. def __init__(self): #初始化链表的头节点以及链表的长度
  9. self.head = Node()
  10. self.length = 0
  11. def __len__(self): #返回链表的长度
  12. return self.length
  13. #定义尾插节点方法
  14. def append(self,value): #添加节点,从末尾处添加
  15. node = Node(value)
  16. if self.length==0:
  17. self.head.next=node
  18. self.length += 1
  19. else:
  20. curnode = self.head.next
  21. while curnode.next!=None:
  22. curnode = curnode.next
  23. curnode.next=node
  24. self.length += 1
  25. #定义链表开始处添加
  26. def start_insert(self,insert_value):#在开始处插入
  27. node = Node(insert_value)
  28. if self.length==0:
  29. self.head.next = node
  30. else:
  31. tmp_node=self.head.next
  32. self.head.next = node
  33. node.next = tmp_node
  34. self.length +=1
  35. #定义在链表任意处添加节点
  36. def insert(self,location,value):#在任意位置插入节点
  37. node = Node(value)
  38. if self.length==0:
  39. self.head.next = node
  40. self.length += 1 #插入一个节点,链表长度加1
  41. else:
  42. for nd in self.iter_node():
  43. if nd.value == location:
  44. tmp_node = nd.next
  45. nd.next = node
  46. node.next = tmp_node
  47. self.length += 1
  48. return True
  49. return False #返回False,未找到插入位置
  50. #定义遍历链表方法
  51. def __iter__(self): #遍历链表节点
  52. for node in self.iter_node():
  53. yield node.value
  54. def iter_node(self):
  55. curnode = self.head.next
  56. while curnode.next !=None:
  57. yield curnode
  58. curnode = curnode.next
  59. if curnode.next == None:
  60. yield curnode
  61. #定义搜索节点方法(按照节点的value搜索)
  62. def search(self,value): #搜索节点
  63. index = 1
  64. if self.length==0: #如果长度为0,则表示链表结构中只有一个头节点
  65. return -1 #返回-1,表示不存在该节点
  66. else:
  67. for node in self.iter_node():
  68. if node.value == value:
  69. return index #搜索到节点的序号
  70. index += 1
  71. return -1 #未搜索到节点
  72. #定义删除节点的方法
  73. def del_node(self,del_value):#删除节点
  74. Flag = False
  75. if self.length==0:
  76. return Flag
  77. else:
  78. previous_node = self.head
  79. for curnode in self.iter_node():
  80. if curnode.value == del_value:
  81. previous_node.next=curnode.next
  82. del curnode
  83. self.length -= 1
  84. Flag = True
  85. else:
  86. previous_node = curnode
  87. return Flag

双链表的实现

  1. #定义节点类
  2. class Node(object):
  3. def __init__(self,value=None,prev=None,next=None):
  4. self.value = value
  5. self.prev = prev
  6. self.next = next
  7. #定义双链表类
  8. class Double_LinkedList(object):
  9. def __init__(self):#初始化双链表只有一个头结点,它的前向指针和后向指针都指向自己,长度为0
  10. node = Node()
  11. node.prev = node
  12. node.next = node
  13. self.head = node
  14. self.length = 0
  15. def __len__(self):
  16. return self.length
  17. def headnode(self): #获取第一个节点
  18. return self.head.next
  19. def tailnode(self): #获取最后一个节点
  20. return self.head.prev
  21. def append(self,value): #添加节点,从末尾添加
  22. node = Node(value)
  23. tail_node = self.tailnode()
  24. tail_node.next = node
  25. node.prev = tail_node
  26. node.next = self.head
  27. self.head.prev = node
  28. self.length += 1
  29. def head_append(self,value): #添加节点,从头添加
  30. node =Node(value)
  31. if self.head.next is self.head:
  32. node.next = self.head
  33. node.prev = self.head
  34. self.head.next = node
  35. self.head.prev = node
  36. else:
  37. node.prev = self.head
  38. head_node = self.headnode()
  39. self.head.next = node
  40. head_node.prev = node
  41. node.next = head_node
  42. self.length += 1
  43. def insert(self,index,value): #在任意位置插入新节点
  44. node = Node(value)
  45. i = 1
  46. if self.length<index:
  47. raise Exception('out of range')
  48. if self.head.next is self.head:
  49. self.head.next = node
  50. self.head.prev = node
  51. node.next = self.head
  52. node.prev = self.head
  53. self.length += 1
  54. return True
  55. else:
  56. if index==0:
  57. self.head_append(value)
  58. return True
  59. for cur_node in self.iter_node():
  60. if i == index:
  61. next_node = cur_node.next
  62. node.prev = cur_node
  63. node.next = next_node
  64. cur_node.next = node
  65. next_node.prev = node
  66. self.length += 1
  67. return True
  68. i += 1
  69. def del_node(self,index): #删除节点
  70. i=1
  71. for cur_node in self.iter_node():
  72. if i == index:
  73. next_node=cur_node.next
  74. prev_node=cur_node.prev
  75. prev_node.next = next_node
  76. next_node.prev = prev_node
  77. self.length -= 1
  78. return True
  79. i += 1
  80. def iter_node(self): #遍历节点
  81. if self.head.next is self.head:
  82. return -1
  83. cur_node = self.head.next
  84. while cur_node.next is not self.head:
  85. yield cur_node
  86. cur_node = cur_node.next
  87. yield cur_node
  88. def __iter__(self): #遍历节点,输出每个节点的值
  89. for node in self.iter_node():
  90. yield node.value
  91. def reverse_iter_node(self):#反向遍历节点
  92. if self.head.prev is self.head:
  93. return False
  94. cur_node = self.head.prev
  95. while cur_node.prev is not self.head:
  96. yield cur_node
  97. cur_node = cur_node.prev
  98. yield cur_node

发表评论

表情:
评论列表 (有 0 条评论,58人围观)

还没有评论,来说两句吧...

相关阅读