单项循环链表

单向循环链表

单链表的一个变形是单向循环链表，链表中最后一个节点的next域不再为None，而是指向链表的头节点。

操作

  • is_empty() 判断链表是否为空
  • length() 返回链表的长度
  • travel() 遍历
  • add(item) 在头部添加一个节点
  • append(item) 在尾部添加一个节点
  • insert(pos, item) 在指定位置pos添加节点
  • remove(item) 删除一个节点
  • search(item) 查找节点是否存在
  1 # ------------节点实现------------
  2 class SingleNode():
  3     """单链表的结点"""
  4     def __init__(self,elem):
  5         # _item存放数据元素
  6         self.elem=elem
  7         # _next是下一个节点的标识
  8         self.next=None
  9 
 10 
 11 # ------------单向循环链表------------
 12 class SinCycLinkedlist():
 13     """单向循环链表"""
 14     def __init__(self,node=None):
 15         self.__head=node
 16         if node:
 17             node.next=node
 18 
 19     def is_empty(self):
 20         """判断链表是否为空"""
 21         return self.__head==None
 22 
 23     def length(self):
 24         """链表长度"""
 25         # cur初始时指向头节点
 26         if self.is_empty():
 27             return 0
 28         cur=self.__head
 29         count=1
 30         # 尾节点指向None，当未到达尾部时
 31         while cur.next!=self.__head:
 32             count+=1
 33             # 将cur后移一个节点
 34             cur=cur.next
 35         return count
 36 
 37     def travle(self):
 38         """遍历链表"""
 39         if self.is_empty():
 40             return None
 41         cur=self.__head
 42         while cur.next!=self.__head:
 43             print(cur.elem,end=' ')
 44             cur=cur.next
 45         print(cur.elem)
 46         # print('')
 47 
 48     def add(self,item):
 49         """头部添加元素---头插法"""
 50         node=SingleNode(item)
 51         if self.is_empty():
 52             self.__head=node
 53             node.next=node
 54         else:
 55             cur=self.__head
 56             # 移到链表尾部，将尾部节点的next指向node
 57             while cur.next!=self.__head:
 58                 cur=cur.next
 59             # 添加的节点指向_head
 60             node.next=self.__head
 61             self.__head=node
 62             # cur.next=node
 63             cur.next=self.__head
 64 
 65     def append(self,item):
 66         """尾部添加元素---尾插法"""
 67         node=SingleNode(item)
 68         # 先判断链表是否为空，若是空链表，则将_head指向新节点
 69         if self.is_empty():
 70             self.__head=node
 71             node.next=node
 72         # 若不为空，则找到尾部，将尾节点的next指向新节点
 73         else:
 74             cur=self.__head
 75             # 移到链表尾部
 76             while cur.next!=self.__head:
 77                 cur=cur.next
 78             # 将node指向头节点_head
 79             node.next=self.__head
 80             # 将尾节点指向node
 81             cur.next=node
 82 
 83     def insert(self,pos,item):
 84         """指定位置添加元素"""
 85         # 若指定位置pos为第一个元素之前，则执行头部插入
 86         if pos<=0:
 87             self.add(item)
 88         # 若指定位置超过链表尾部，则执行尾部插入
 89         elif pos>(self.length()-1):
 90             self.append(item)
 91         # 找到指定位置
 92         else:
 93             node=SingleNode(item)
 94             count=0
 95             # pre用来指向指定位置pos的前一个位置pos-1，初始从头节点开始移动到指定位置
 96             pre=self.__head
 97             while count<(pos-1):
 98                 count+=1
 99                 pre=pre.next
100             # 先将新节点node的next指向插入位置的节点
101             node.next=pre.next
102             # 将插入位置的前一个节点的next指向新节点
103             pre.next=node
104 
105     def search(self,item):
106         """链表查找节点是否存在，并返回True或者False"""
107         cur=self.__head
108         while cur!=None:
109             if cur.elem==item:
110                 return True
111             else:
112                 cur=cur.next
113         return False
114 
115     def remove(self,item):
116         """删除节点"""
117         if self.is_empty():
118             return
119 
120         cur=self.__head
121         pre=None
122 
123         while cur.next!=self.__head:
124             # 找到了指定元素
125             if cur.elem==item:
126                 # 先判断此节点是否是头节点
127                 if cur==self.__head:
128                     # 头节点的情况
129                     #找尾节点
130                     rear=self.__head
131                     while rear.next!=self.__head:
132                         rear=rear.next
133                     self.__head=cur.next
134                     rear.next=self.__head
135                 else:
136                     # 中间节点
137                     pre.next=cur.next
138                 return
139             else:
140                 # 继续按链表后移节点
141                 pre=cur
142                 cur=cur.next
143         #退出循环,cur指向尾结点
144         if cur.elem==item:
145             if cur==self.__head:
146                 #链表只有一个节点
147                 self.__head=None
148             else:
149                 pre.next=self.__head
150 
151 if __name__ == '__main__':
152     li=SinCycLinkedlist()
153     print(li.is_empty())
154     print(li.length())
155 
156     li.append(1)
157     li.add(4)
158     li.append(2)
159     li.append(3)
160     # print(li.is_empty())
161     # print(li.length())
162     li.travle()
163     li.insert(-1,5)
164     li.travle()
165     li.insert(2,6)
166     li.travle()
167     li.insert(8,7)
168     li.travle()
169     print(li.search(5))
170     li.remove(5)
171     li.travle()
172     li.remove(1)
173     li.travle()
174     li.remove(20)
175     li.travle()
 1 #执行结果
 2 True
 3 0
 4 4 1 2 3
 5 5 4 1 2 3
 6 5 4 6 1 2 3
 7 5 4 6 1 2 3 7
 8 True
 9 4 6 1 2 3 7
10 4 6 2 3 7
11 4 6 2 3 7

 

posted on 2019-09-18 20:45  cherry_ning  阅读(141)  评论(0)    收藏  举报

导航