1. python中内置计算算法效率的类
class timeit.Timer(stmt=‘pass’, setup=‘pass’, timer=)
Timer是测量小段代码执行速度的类。
stmt参数是要测试的代码语句（statment）；
setup参数是运行代码时需要的设置；
timer参数是一个定时器函数，与平台有关。
timeit.Timer.timeit(number=1000000)
def test1():
l = []
for i in range(1000):
l = l + [i]
def test2():
l = []
for i in range(1000):
l.append(i)
def test3():
l = [i for i in range(1000)]
def test4():
l = list(range(1000))
from timeit import Timer
t1 = Timer("test1()", "from __main__ import test1")
print("concat ",t1.timeit(number=1000), "seconds")
t2 = Timer("test2()", "from __main__ import test2")
print("append ",t2.timeit(number=1000), "seconds")
t3 = Timer("test3()", "from __main__ import test3")
print("comprehension ",t3.timeit(number=1000), "seconds")
t4 = Timer("test4()", "from __main__ import test4")
print("list range ",t4.timeit(number=1000), "seconds")
# ('concat ', 1.7890608310699463, 'seconds')
# ('append ', 0.13796091079711914, 'seconds')
# ('comprehension ', 0.05671119689941406, 'seconds')
# ('list range ', 0.014147043228149414, 'seconds')
2.单链表的python实现
class SingleNode(object):
"""单链表的结点"""
def __init__(self,item):
# _item存放数据元素
self.item = item
# _next是下一个节点的标识
self.next = None
# is_empty() 链表是否为空
# length() 链表长度
# travel() 遍历整个链表
# add(item) 链表头部添加元素
# append(item) 链表尾部添加元素
# insert(pos, item) 指定位置添加元素
# remove(item) 删除节点
# search(item) 查找节点是否存在
class SingleLinkList(object):
"""单链表"""
def __init__(self):
self._head = None
def is_empty(self):
if self._head:
return True
else:
return False
def travel(self):
cur = self._head
count = 1
while cur != None:
print(count ," ", cur.item)
count += 1
cur = cur.next
def length(self):
cur = self._head
count = 1
while cur != None:
count += 1
cur = cur.next
return count
# add(item) 链表头部添加元素
def add(self, item):
node = SingleNode(item)
node.next = self._head
self._head = node
# append(item) 链表尾部添加元素
def append(self, item):
node = SingleNode(item)
if self._head == None:
self._head = node
cur = self._head
while cur.next != None:
cur = cur.next
cur.next = node
#insert(pos, item) 指定位置添加元素
def insert(self, pos, item):
node = SingleNode(item)
len = self.length()
cur = self._head
count = 1
if pos <= 0 or pos > len:
print('Please input position from',1, "to", len)
while count < (pos-1):
count += 1
cur = cur.next
node.next = cur.next
cur.next = node
#remove(item) 删除节点
def remove(self, item):
#先移除头结点
if self._head.item == item:
self._head = self._head.next
cur = self._head
#移除除头结点以外的结点
while cur.next != None:
if cur.next.item == item:
cur.next = cur.next.next
break
cur = cur.next
def search(self, item):
cur = self._head
count = 1
while cur != None:
if cur.item == item:
return True
count += 1
return False
if __name__ == "__main__":
s = SingleLinkList()
for i in range(5):
s.add(i)
s.append(10)
# s.insert(3, 90)
print(s.search(4))
s.remove(4)
s.remove(0)
s.travel()
print(s.is_empty())
3.栈的python实现
# Stack() 创建一个新的空栈
# push(item) 添加一个新的元素item到栈顶
# pop() 弹出栈顶元素
# peek() 返回栈顶元素
# is_empty() 判断栈是否为空
# size() 返回栈的元素个数
class Stack(object):
"""栈"""
def __init__(self):
self.items = []
def is_empty(self):
return self.items == []
# push(item) 添加一个新的元素item到栈顶
def push(self, item):
self.items.append(item)
def pop(self):
self.items.pop()
def size(self):
return len(self.items)
def travel(self):
for item in self.items:
print(item)
def peek(self):
length = self.size()
return self.items[length - 1]
if __name__ == '__main__':
s = Stack()
for i in range(1, 10):
s.push(i)
s.pop()
print('peek', s.peek())
s.travel()
4.队列
# Queue() 创建一个空的队列
# enqueue(item) 往队列中添加一个item元素
# dequeue() 从队列头部删除一个元素
# is_empty() 判断一个队列是否为空
# size() 返回队列的大小
class Queue(object):
"""队列尾部进去，头部出来"""
def __init__(self):
self.items = []
# enqueue(item) 往队列中添加一个item元素
def enqueue(self, item):
length = self.size()
self.items.insert(length, item)
def size(self):
return len(self.items)
# dequeue() 从队列头部删除一个元素
def dequeue(self):
length = self.size()
self.items.pop(0)
def is_empty(self):
return self.items == []
def travel(self):
for item in self.items:
print(item)
if __name__ == '__main__':
q = Queue()
for i in range(5):
q.enqueue(i)
q.dequeue()
q.travel()
5.几种常见的排序实现
def selection_sort(list):
length = len(list)
for i in range(length):
max_num = list[0]
pos = 0
for j in range(length-i):
if max_num < list[j]:
max_num = list[j]
pos = j
temp = list[pos]
list[pos] = list[length-i-1]
list[length-i-1] = temp
# print(i, " ", temp)
return list
def insert_sort(list):
length =len(list)
for i in range(length):
for j in range(i, 0, -1):
if list[j] < list[j-1]:
temp = list[j]
list[j] = list[j-1]
list[j-1] = temp
return list
#递归
def quick_sort(alist, start, end):
if start >= end:
return
middle_num = alist[start]
high = end
low = start
while low < high:
#指针前移
while low < high and alist[high] >= middle_num:
high = high - 1
alist[low] = alist[high]
#指针后移
while low < high and alist[low] <= middle_num:
low = low-1
alist[high] = alist[low]
alist[low] = middle_num
#递归
quick_sort(alist, start, low-1)
quick_sort(alist, low+1, end)
return alist
#希尔排序
def shell_sort(alist):
pass
#归并排序
def merge_sort(alist):
if len(alist) <= 1:
return alist
num = int(len(alist)/2)
#将子序列都算出，然后归并
left = merge_sort(alist[num:])
right = merge_sort(alist[:num])
# print("left", left, "right", right)
return merge(left, right)
#归并
def merge(left, right):
left_index = 0
right_index = 0
result = []
while left_index < len(left) and right_index < len(right) :
if left_index < len(left) and left[left_index] > right[right_index]:
result.append(right[right_index])
right_index += 1
if right_index < len(right) and left[left_index] <= right[right_index]:
result.append(left[left_index])
left_index += 1
result += right[right_index:]
result += left[left_index:]
return result
if __name__ == '__main__':
L = [3, 5, 14, 1, 89, 2]
print("selection_sort", selection_sort(L))
print("insert_sort", insert_sort(L))
print("quick_sort", quick_sort(L, 0 ,len(L)-1))
print("merge_sort", merge_sort(L))
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
