数据结构的基本实现

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))