1.单向链表
单链表节点一个类，单链表一个类，单链表这个类中的元素都是节点类的。
单链表的操作：
is_empty() 链表是否为空
取cur指向链表的首节点，判断是不是Nonelength() 链表长度
取cur指向链表的首节点，设置count用来计数，当前指向若不为None，则计数+1，移动cur指向下一个节点。travel() 遍历整个链表
思路同链表长度，把计数的部分换成print-
first_add(item) 链表头部添加元素
新添加的元素需要定义成节点类的一个实例。新添加的元素就是头节点，新添加节点的下一个指向原链表的头节点。把链表的头节点指向新添加的节点。
last_add(item) 链表尾部添加元素
新添加的元素需要定义成节点类的一个实例。
判断当前链表是不是为空，如果是空，那这个链表的头节点指向新添加的节点。
如果不是空，那就将cur指向头节点，按照travel()的思路遍历这个链表，一直走到最后一个节点，将最后一个节点的下一个元素设置为新添加的这个节点。注意判断是否最后一个节点的条件。-
insert(pos, item) 指定位置添加元素
新添加的元素需要定义成节点类的一个实例。
判断pos的值，如果pos<=0，则相当于在首部插入，调用首部插入的方法。
如果pos的值>链表长度-1(注意这里pos的值是从0开始的)，则相当于尾部插入，调用尾部插入的方法。
否则：定义pre指向当前链表的头节点，用一个count计算当前指向的索引值，移动cur直到走到pos-1的位置，将新节点的下一个元素指向原链表这个位置的下一个元素，原链表的下一个位置指向新节点。见下图
-
remove(item) 删除节点
扫描二维码关注公众号，回复： 5190677 查看本文章
定义两个指针，pre一开始是None，cur 指向原链表的头节点。如果删除的是头节点，那么把链表的头节点指向原链表头节点的下一个节点。如果不是头节点，就将pre指向当前cur的节点，cur的指向一个一个的往后挪，（这样就相当于pre在后，cur在前）直到cur指向的值就是我们要删除的值，把pre的下一个节点指向cur的下一个节点。
search(item) 查找节点是否存在
思路同travel()
class Node(object):
def __init__(self,item):
self.item = item
self._next = None
class singleLinkList(object):
def __init__(self):
# 头节点
self._head = None
def is_empty(self):
return self._head == None
def length(self):
# 首先要指向头节点
cur = self._head
count = 0
while cur is not None:
count = count+1
cur = cur._next
return count
def travel(self):
if self.is_empty():
return
# 首先要指向头节点
cur = self._head
while cur != None:
print(cur.item)
cur = cur._next
print("")
def first_add(self,elem):
# 把新添加的数定义到Node类里，这样它就会有item和_next两个属性
p = Node(elem)
p._next = self._head
# 把链表的头节点指向新添加的节点
self._head = p
def last_add(self,elem):
cur = self._head
p = Node(elem)
# 首先判断这个链表是不是空的
if self.is_empty():
self._head = p
else:
cur = self._head
while cur._next != None:
cur = cur._next
cur._next = p
def insert(self,index,elem):
# 如果插入的地方在第一个位置之前，直接调用在首部插入的方法
if index<=0 :
self.first_add(elem)
# 如果插入的地方在最后一个位置之后，直接调用在尾部插入的方法
elif index>(self.length()-1):
self.last_add(elem)
else:
p = Node(elem)
count = 0
pre = self._head
while count<(index-1):
pre = pre._next
count = count+1
p._next = pre._next
pre._next = p
def remove(self,elem):
cur = self._head
pre = None
while cur is not None:
if cur.item == elem:
# 如果第一个就是要删除的节点
if not pre:
self._head = cur._next
else:
pre._next = cur._next
break
else:
# 将删除位置前一个节点的next指向删除位置的后一个节点
pre = cur
cur = cur._next
def search(self,elem):
cur = self._head
index = 0
while cur is not None:
if cur.item == elem:
return index
else:
cur = cur._next
index = index+1
return index
if __name__ == "__main__":
ll = singleLinkList()
print("-------创建链表，首部加1，首部加2---------")
ll.first_add(1)
# print(ll.travel())
ll.first_add(2)
ll.travel()
print("-------尾部添加3---------")
ll.last_add(3)
ll.travel()
print("-------在索引为2的位置添加4---------")
ll.insert(2, 4)
print("length:",ll.length())
ll.travel()
print("-------查找链表中某一个数的索引---------")
index = ll.search(2)
print(index)
print("-------删除链表中某一个数---------")
ll.remove(3)
# print "length:",ll.length()
ll.travel()
2.循环单链表
-
首部添加元素
首先判断这个链表是不是空，如果是空，把头指针指向新添加的这个p节点，并且p节点的下一节点指向头节点。（因为是循环的）
如果不是空，那么先把p节点的下一个节点指向头节点，然后往后走，找到最后一个节点，把原链表的最后一个节点的下一个节点指向新加入的p节点，并且把头指针指向这个p节点（因为是首部加入） - 尾部添加元素
首先判断原链表是不是空的，如果是空的，就按照上面的，把头指针(self._head)指向新添加的这个p节点，并且p节点的下一节点指向头节点。
如果不是空，就找到原链表的最后一个节点，将最后一个节点的下一节点指向p节点，然后p节点的下一个节点指向头节点，头指针(self._head)没变。 - remove方法还需要好好看看。
class Node(object):
def __init__(self,item):
self.item = item
self._next = None
class circularLinkList(object):
def __init__(self):
# 头节点
self._head = None
def is_empty(self):
return self._head == None
def length(self):
# 首先要指向头节点
cur = self._head
count = 0
while cur is not None:
count = count+1
cur = cur._next
return count
def travel(self):
if self.is_empty():
return
# 首先要指向头节点
cur = self._head
while cur._next != self._head:
print(cur.item)
cur = cur._next
print(cur.item)
print("")
def first_add(self,elem):
# 把新添加的数定义到Node类里，这样它就会有item和_next两个属性
p = Node(elem)
if self.is_empty():
self._head = p
p._next = self._head
else:
# 首先将新加入的这个节点的下一个节点指向首节点
p._next = self._head
# 然后将原链表的尾节点指向这个新加入的节点
cur = self._head
while cur._next != self._head:
cur = cur._next
cur._next = p
self._head = p
def last_add(self,elem):
p = Node(elem)
# 首先判断这个链表是不是空的
if self.is_empty():
self._head = p
p._next = self._head
else:
# 直接走到最后的节点
cur = self._head
while cur._next != self._head:
cur = cur._next
cur._next = p
p._next = self._head
def insert(self,index,elem):
# 如果插入的地方在第一个位置之前，直接调用在首部插入的方法
if index<=0 :
self.first_add(elem)
# 如果插入的地方在最后一个位置之后，直接调用在尾部插入的方法
elif index>(self.length()-1):
self.last_add(elem)
else:
p = Node(elem)
count = 0
pre = self._head
while count<(index-1):
pre = pre._next
count = count+1
p._next = pre._next
pre._next = p
def remove(self,elem):
# 如果原链表为空
if self.is_empty():
return
cur = self._head
pre = None
# 如果链表的第一个元素就是要删除的元素
if cur.item == elem:
# 如果链表多于一个节点，就找到最后一个节点
if cur._next != self._head:
while cur._next != self._head:
cur = cur._next
cur._next = self._head._next
self._head = self._head._next
else:
# 如果链表只有一个元素，就直接置空
self._head = None
else:
pre = self._head
while cur._next != self._head:
# 如果找到了要找的元素
if cur.item == elem:
pre._next = cur._next
return
else:
pre = cur
cur = cur._next
# cur指向了尾节点
if cur.item == elem:
pre._next = self._head
def search(self,elem):
if self.is_empty():
return False
cur = self._head
index = 0
while cur._next != self._head:
if cur.item == elem:
return index
else:
cur = cur._next
index = index+1
if cur.item == elem:
return index
else:
return False
if __name__ == "__main__":
ll = circularLinkList()
# print(ll.length())
ll.travel()
print("--------首部添加----------")
ll.first_add(2)
ll.first_add(1)
ll.first_add(99)
ll.travel()
print("--------尾部添加----------")
ll.last_add(6)
ll.travel()
print("--------尾部添加----------")
ll.last_add(5)
ll.travel()
print("--------移除元素----------")
# ll.remove(5)
# ll.travel()
print("--------查找元素----------")
print(ll.search(6))
3.冒泡排序（将大的数冒泡到最后）
思路：比较前后两个数的大小，从前到后比较到最后，这样第一次冒泡完最后一个数是整个里面最大的数，然后进行第二次冒泡，总共需要n-1次冒泡。