1 def bubble_sort(alist):2     """冒泡排序"""3     n = len(alist)4     for j in range(n-1):5         for i in range(0,n-1-j):6             if alist[i] > alist[i+1]:7                 alist[i], alist[i+1] = alist[i+1], alist[i]8         print(alist)9     return alist
10
11
12 if __name__ == "__main__":
13     list_01 = [1,4,2,7,3,9,6,5,8,0]
14     print(list_01)
15     print(bubble_sort(list_01))

1 #-*- coding:utf-8 -*-2 # username:MR3 # 使用插入法实现链表的逆序4 #主要思路是：从链表的第二个节点开始，把遍历到的节点插入到头节点的后面，直到遍历结束5 6 class LNode:7     """定义节点类"""8     def __init__(self, x):9         self.data = x
10         self.next = None
11
12 def Reverse(head): # head 表示头节点
13     # 判断链表是否为空
14     if head == None or head.next == None :
15         return
16
17     cur = None # 初始化当前节点
18     next = None # 初始化后继节点
19     cur = head.next.next  # 设置第二个节点是当前节点
20     head.next.next = None #设置链表的第一个节点为尾节点
21
22     #把遍历到的节点插入到头节点的后面
23     while cur is not None:
24         next = cur.next #定义临时变量存储当前n节点的链接区地址
25         cur.next = head.next #把n节点的链接区指向新的地址，即第一个节点
26         head.next = cur #把头节点的链接区指向n节点，此时第n个节点已经被放到的第一个节点的位置
27         cur = next #定义新的cur位置，即n+1个节点
28
29 if __name__ == "__main__":
30     i = 1
31     #链表头节点
32     head = LNode(i) #定义头节点，数据区为i，链接区为None
33     head.next = None
34     tmp = None
35     cur = head  #将头节点设置为当前节点
36     #构造单链表
37     while i<8:
38         tmp = LNode(i) #定义一个tmp节点
39         tmp.next = None #节点的链接区为空
40         cur.next = tmp #将当前节点的链接区指向tmp节点
41         cur = tmp #将tmp节点设置为当前节点，即游标向后移动一位
42         i += 1
43     print("逆序前的链表为：")
44     cur = head.next #重新设置第一个节点为当前节点
45     while cur!=None:
46         print(cur.data, end=" ")
47         cur = cur.next
48     print("\n逆序后的链表为：")
49     Reverse(head) #逆序链表
50     cur = head.next #重新设置第一个节点为当前节点
51     while cur!=None:
52         print(cur.data, end=" ")
53         cur = cur.next

 1 #-*- coding:utf-8 -*-2 # username:MR3 # 给定一个无序的链表，去掉其中的重复项4 5 6 # 定义节点类7 class LNode:8     def __init__(self, x):9         self.data = x10         self.next = None11 12 13 # 方法一：递归法14 # 主要思路：对于节点cur，首先递归地删除以cur.next为首的子链表中重复的节点，然后以cur.next为首的子链表中找到与cur有相同数据域的节点并删除15 def removeDupRecursion(head):16     if head.next == None:17         return head18 19     pointer = None20     cur = head21 22     # 对以head.next为首的子链表删除重复的节点23     head.next = removeDupRecursion(head.next)24     pointer = head.next25 26     # 找出以head.next为首的子链表中与head节点相同的节点并删除27     while pointer is not None:28         if head.data == pointer.data:29             cur.next = pointer.next30             pointer = cur.next31         else:32             pointer = pointer.next33             cur = cur.next34     return head35 36 """对带头节点的单链表删除重复的节点37     输入参数： head：链表头节点"""38 def removeDup_1(head):39     if (head is None):40         return41     head.next = removeDupRecursion(head.next)42 43 44 # 方法二：顺序删除45 """ 主要思路：通过双重循环直接在链表上进行删除操作。外层循环用一个指针从第一个节点开始遍历整个链表，然后内层循环用另一个指针遍历其余节点,46 将与外层循环遍历的指针所指节点的数据域相同的节点删除。47 """48 def removeDup_2(head):49     if head==None or head.next==None:50         return51 52     outerCur = head.next # 用于外层循环，指向链表的第一个节点53     innerCur = None # 用于内层循环，用来遍历outerCur后面的节点54     innerPre = None # innerCur的前驱节点55 56     while outerCur != None:57         innerCur = outerCur.next58         innerPre = outerCur59         while innerCur != None:60             # 找到重复的节点并删除61             if outerCur.data == innerCur.data:62                 innerPre.next = innerCur.next63                 innerCur = innerCur.next64             else:65                 innerPre = innerCur66                 innerCur = innerCur.next67         outerCur = outerCur.next68 69 70 71 72 if __name__ == "__main__":73     i = 174     head = LNode(i)75     head.next = None76     tmp = None77     cur = head78     while i<7:79         tmp = LNode(i)80         if i%2==0:81             tmp.data = i+182         elif i%3==0:83             tmp.data = i-284         else:85             tmp.data = i86         tmp.next = None87         cur.next = tmp88         cur = tmp89         i += 190     print("逆序前的链表为：")91     cur = head.next  # 重新设置第一个节点为当前节点92     while cur != None:93         print(cur.data, end=" ")94         cur = cur.next95     print("\n删除重复节点后的链表为：")96     removeDup_1(head)  # 逆序链表97     # removeDup_2(head)  # 逆序链表98     cur = head.next  # 重新设置第一个节点为当前节点99     while cur != None:
100         print(cur.data, end=" ")
101         cur = cur.next

 1 #-*- coding:utf-8 -*-2 # username:MR3 4 class MyStack:5     """利用有序列表模拟栈"""6     # 定义一个空的栈7     def __init__(self):8         self.items = []9     # 判断栈是否为空
10     def isEmpty(self):
11         return len(self.items)==0
12     #  返回栈的大小
13     def size(self):
14         return len(self.items)
15     # 返回栈顶元素，把列表最后一个元素作为栈顶元素，这里只是返回，不删除
16     def top(self):
17         if not self.isEmpty():
18             return self.items[len(self.items)-1]
19         else:
20             return None
21     # 弹栈，弹出列表中最后一个元素
22     def pop(self):
23         if len(self.items)>0:
24             return self.items.pop()
25         else:
26             print("栈已经为空")
27             return None
28     # 压栈，在列表的最后加入一个元素
29     def push(self,item):
30         self.items.append(item)
31
32 if __name__ == "__main__":
33     s = MyStack()
34     s.push(4)
35     s.push(5)
36     print("栈顶元素为:%s" % str(s.top()))
37     print("栈的大小为:%s" % str(s.size()))
38     s.pop()
39     print("弹栈成功")
40     s.pop()

 1 #-*- coding:utf-8 -*-
 2 # username:MR
 3
 4 class LNode:
 5     def __init__(self,x):
 6         self.data = x
 7         self.next = None
 8
 9 class MyStack:
10     def __init__(self):
11         # pHead = LNode()
12         self.data = None
13         self.next = None
14     # 判断stack是否为空，如果为空返回true，否则返回false
15     def empty(self):
16         if self.next == None:
17             return True
18         else:
19             return False
20     # 获取栈中的元素个数
21     def size(self):
22         size = 0
23         p = self.next
24         while p != None:
25             p = p.next
26             size += 1
27         return size
28     # 入栈：把e放到栈顶
29     def push(self,e):
30         p = LNode(e)
31         # p.data = e
32         p.next = self.next
33         self.next = p
34     # 出栈，同时返回该元素
35     def pop(self):
36         tmp = self.next
37         if tmp != None:
38             self.next = tmp.next
39             return tmp.data
40     # 取得栈顶元素
41     def top(self):
42         if self.next != None:
43             return self.next.data
44         print("栈已空")
45         return None
46
47 if __name__ == "__main__":
48     stack = MyStack()
49     stack.push(1)
50     stack.push(3)
51     print("栈顶元素为：%s" % str(stack.top()))
52     print("栈大小为：%s" % str(stack.size()))
53     stack.pop()
54     print("出栈成功")
55     stack.pop()

#-*- coding:utf-8 -*-
# username:MR"""队列：先入先出
用front记录首元素的位置，用rear记录尾元素后一个位置，
入列时只要将待入列的元素放入数组下标为rear的位置，同时将rear+1，
出列时只需要将front+1即可
"""class MyQueue:def __init__(self):self.arr = []self.front = 0self.rear = 0# 判断队列是否为空def isEmpty(self):return self.front==self.rear# 返回队列的大小def size(self):return self.rear-self.front# 返回队列的首元素def getFront(self):if self.isEmpty():return Nonereturn self.arr[self.front]# 返回队列的尾元素def getBack(self):if self.isEmpty():return Nonereturn self.arr[self.rear-1]# 删除队列头元素（出列）def deQueue(self):if self.rear>self.front:self.front+=1else:print("队列已经为空")# 把新元素加入到队列尾部（入列）def enQueue(self, item):self.arr.append(item)self.rear+=1if __name__ == "__main__":queue = MyQueue()queue.enQueue(1)queue.enQueue(2)print("队列头元素为： %s" % str(queue.getFront()))print("队列尾元素为： %s" % str(queue.getBack()))print("队列的大小为： %s" % str(queue.size()))

#-*- coding:utf-8 -*-
# username:MR# 先定义一个栈
class Stack:def __init__(self):self.items = []# 判断栈是否为空def empty(self):return len(self.items)==0#  返回栈的大小def size(self):return len(self.items)# 返回栈顶元素，把列表最后一个元素作为栈顶元素，这里只是返回，不删除def peek(self):if not self.empty():return self.items[len(self.items)-1]else:return None# 弹栈，弹出列表中最后一个元素def pop(self):if len(self.items)>0:return self.items.pop()else:print("栈已经为空")return None# 压栈，在列表的最后加入一个元素def push(self,item):self.items.append(item)"""
方法功能：把栈底元素移动到栈顶
参数：s栈的引用
"""
def moveBottomToTop(s):if s.empty():returntop1 = s.peek()s.pop() # 弹出栈顶元素if not s.empty():# 递归处理不包含栈顶元素的子栈
        moveBottomToTop(s)top2=s.peek()s.pop()# 交换栈顶元素与子栈栈顶元素
        s.push(top1)s.push(top2)else:s.push(top1)def reverse_stack(s):if s.empty():return# 把栈底元素移动到栈顶
    moveBottomToTop(s)top=s.peek()s.pop()# 递归处理子栈
    reverse_stack(s)s.push(top)if __name__ == "__main__":s=Stack()s.push(5)s.push(4)s.push(3)s.push(2)s.push(1)reverse_stack(s)print("翻转后出栈顺序为：")while not s.empty():print(s.peek())s.pop()

 1 #-*- coding:utf-8 -*-
 2 # username:MR
 3
 4 # 先定义一个栈
 5 class Stack:
 6     def __init__(self):
 7         self.items = []
 8     # 判断栈是否为空
 9     def empty(self):
10         return len(self.items)==0
11     #  返回栈的大小
12     def size(self):
13         return len(self.items)
14     # 返回栈顶元素，把列表最后一个元素作为栈顶元素，这里只是返回，不删除
15     def peek(self):
16         if not self.empty():
17             return self.items[len(self.items)-1]
18         else:
19             return None
20     # 弹栈，弹出列表中最后一个元素
21     def pop(self):
22         if len(self.items)>0:
23             return self.items.pop()
24         else:
25             print("栈已经为空")
26             return None
27     # 压栈，在列表的最后加入一个元素
28     def push(self,item):
29         self.items.append(item)
30
31 def moveBottomToTop(s):
32     if s.empty():
33         return
34     top1=s.peek()
35     s.pop()
36     if not s.empty():
37         moveBottomToTop(s)
38         top2=s.peek()
39         if top1>top2:
40             s.pop()
41             s.push(top1)
42             s.push(top2)
43             return
44     s.push(top1)
45
46 def sortStack(s):
47     if s.empty():
48         return
49     # 把栈底元素移动到栈顶
50     moveBottomToTop(s)
51     top=s.peek()
52     s.pop()
53     # 递归处理子栈
54     sortStack(s)
55     s.push(top)
56
57 if __name__ == "__main__":
58     s=Stack()
59     s.push(1)
60     s.push(4)
61     s.push(3)
62     sortStack(s)
63     print("排序后出栈顺序为：")
64     while not s.empty():
65         print(s.peek(),end=" ")
66         s.pop()