Python基础算法：排序、查找、二叉树

排序算法

1、插入排序

import random

"""头插法"""
def insert(ls):
	for i in range(len(ls)-1):
		print('\033[036m',i,ls,'\033[0m')
		min_=ls[i]
		index=i
		for j in range(i+1,len(ls)):
			if ls[j]<min_:
				min_=ls[j]
				index=j
		ls.insert(i,min_)
		del ls[index+1]
	return ls
a=[0,11,22,33,44,55,66,77,88,99]
random.shuffle(a)
print(insert(a))

"""尾插法"""
def append_sort(ls):
    for i in range(len(ls),0,-1):
        min_=ls[0]
        index=0
        print('\033[36m',i,ls,'\033[0m')
        for j in range(i):
            if ls[j]<min_:
                min_=ls[j]
                index=j
        ls.append(min_)
        del ls[index]
    return ls
a=[0,11,22,33,44,55,66,77,88,99]
random.shuffle(a)
print(append_sort(a))

2、交换排序

import random

def interchange(ls):
	for i in range(len(ls)-1):
		print('\033[036m',i,ls,'\033[0m')
		min_=ls[i]
		index=i
		for j in range(i+1,len(ls)):
			if ls[j]<min_:
				min_=ls[j]
				index=j
		ls[i],ls[index]=min_,ls[i]
	return ls

a=[0,11,22,33,44,55,66,77,88,99]
random.shuffle(a)
print(interchange(a))

3、冒泡排序

import random

def bubble(ls):
    go_on=1
    for i in range(len(ls)-1):
        print('\033[036m',i,ls,'\033[0m')
        go_on=0
        for j in range(len(ls)-1,i,-1):
            if ls[j]<ls[j-1]:
                ls[j-1],ls[j]=ls[j],ls[j-1]
                go_on=1
        if not go_on:
            break
    return ls

a=[0,11,22,33,44,55,66,77,88,99]
random.shuffle(a)
print(bubble(a))

4、归并排序

4.1、合并两个有序序列

def merge(ls1,ls2):
    ls3=[]
    i=j=0
    while i<len(ls1) and j<len(ls2):
        if ls1[i]<ls2[j]:
            ls3.append(ls1[i])
            print('\033[036m',i,ls3,'\033[0m')
            i+=1
        else:
            ls3.append(ls2[j])
            print('\033[036m',j,ls3,'\033[0m')
            j+=1
    if i<len(ls1):
        for ii in ls1[i:]:
            ls3.append(ii)
    else:
        for jj in ls2[j:]:
            ls3.append(jj)
    return ls3

a=[1,3,5,6]
b=[0,2,4,7,8,9]
c=merge(a,b)
print(c)

4.2、完整版

def merge(ls1, ls2):
    ls3 = []
    i = j = 0
    while i < len(ls1) and j < len(ls2):
        if ls1[i] < ls2[j]:
            ls3.append(ls1[i])
            i += 1
        else:
            ls3.append(ls2[j])
            j += 1
    if i < len(ls1):
        ls3.extend(ls1[i:])
    else:
        ls3.extend(ls2[j:])
    return ls3

def merge_sort(ls):
    if len(ls) <= 1:
        return ls
    half = int(len(ls) / 2)
    left = merge_sort(ls[:half])
    right = merge_sort(ls[half:])
    return merge(left, right)

from random import shuffle
ls = list(range(9))
shuffle(ls)
print(ls)
print(merge_sort(ls))

查找算法

1、顺序查找

# sequential search
def sequential(ls,value):
    for i in range(len(ls)):
        print('\033[036m',i,ls[i],'\033[0m')  # show steps
        if ls[i]==value:
            return i

l=[0,11,22,33,44,55,66,77,88,99]
print(l)
for i in range(9):
    v=int(input('look up number').strip())
    print(sequential(l,v))

2、二分查找

# binary search
def binary(ls,value):
    head,tail=0,len(ls)-1
    mid=(head+tail)//2
    while head<=tail:
        if ls[mid]==value:
            return mid
        elif value<ls[mid]:
            print('\033[036m',mid,ls[mid],'\033[0m')  # show steps
            tail=mid-1
            mid=(head+tail)//2
        elif ls[mid]<value:
            print('\033[036m',mid,ls[mid],'\033[0m')  # show steps
            head=mid+1
            mid=(head+tail)//2

l=[0,11,22,33,44,55,66,77,88,99]
print(l)
for i in range(9):
    v=int(input('look up number').strip())
    print(binary(l,v))

3、字符串查找

def find(sentence, word, start=0, end=9999):
    len_s = len(sentence)
    len_w = len(word)
    end = min(len_s - len_w + 1, end)
    for i in range(start, end):
        if word == sentence[i: i + len_w]:
            return i
    return -1

s = 'To see a world in a grain of sand. And a heaven in wild flower.'
print(find(s, ' a '))
print(find(s, ' a ', 7))
print(find(s, ' a ', 7, 17))

完全二叉树

1、创建树节点【TN】、创建树【FBT】、打印树【FBT.tree】

import math
# Tree Node
class TN:
    def __init__(self, data, left=None, right=None):
        self.data = data
        self.left = left
        self.right = right
    def __str__(self):
        return str(self.data)


# Full Binary Tree
class FBT:
    def __init__(self, ls):
        self.nodes = [TN(i) for i in ls]
        for i in range(len(self.nodes)-1, 0, -1):
            if i % 2 == 0:
                self.nodes[int(i/2-1)].right = self.nodes[i]
            else:
                self.nodes[int(i/2)].left = self.nodes[i]
        self.tree()
    # 树结构
    def tree(self):
        # 节点数
        length = len(self.nodes)
        # 总层数
        layers = math.ceil(math.log2(length))
        # 总宽度
        width = 2 ** layers - 1
        # 分隔符
        branch = ' '
        # 初始化顶层,并打印
        layer = [self.nodes[0].data]
        interval = 2 ** layers - 1
        for i in range(2, length + 1):
            if math.log2(i) % 1 == 0:
                # 打印当前层
                print((branch * interval).join(layer).center(width))
                layer = []
            # 元素进入当前层
            layer.append(self.nodes[i - 1].data)
            # 节点间空隙
            interval = 2 ** (layers - int(math.log2(i))) - 1
        # 打印底层
        print(branch.join(layer))
ls = [chr(i) for i in range(65, 91)]
fbt = FBT(ls)

打印结果

               A               
       B               C       
   D       E       F       G   
 H   I   J   K   L   M   N   O 
P Q R S T U V W X Y Z

2、递归法遍历

# 先序遍历
def preorder_traversal(node):
    print('%3s' % node, end='')
    if node.left:
        preorder_traversal(node.left)
    if node.right:
        preorder_traversal(node.right)
# 中序遍历
def inorder_traversal(node):
    if node.left:
        inorder_traversal(node.left)
    print('%3s' % node, end='')
    if node.right:
        inorder_traversal(node.right)
# 后序遍历
def postorder_traversal(node):
    if node.left:
        postorder_traversal(node.left)
    if node.right:
        postorder_traversal(node.right)
    print('%3s' % node, end='')
# traversal
print('\npreorder')
preorder_traversal(fbt.nodes[0])
print('\ninorder')
inorder_traversal(fbt.nodes[0])
print('\npostorder')
postorder_traversal(fbt.nodes[0])

打印结果

preorder
  A  B  D  H  P  Q  I  R  S  E  J  T  U  K  V  W  C  F  L  X  Y  M  Z  G  N  O
inorder
  P  H  Q  D  R  I  S  B  T  J  U  E  V  K  W  A  X  L  Y  F  Z  M  C  N  G  O
postorder
  P  Q  H  R  S  I  D  T  U  J  V  W  K  E  B  X  Y  L  Z  M  F  N  O  G  C  A

3、递归效率较低，可改用【栈】

# 先序遍历
def preorder_traversal(node):
    ls = []
    while True:
        # 节点不为空时
        while node:
            print('%3s' % node, end='')
            # 入栈
            ls.append(node)
            # 进入左节点
            node = node.left
        # 栈为空时退出
        if ls == []:
            break
        # 出栈
        node = ls.pop()
        # 进入右节点
        node = node.right
# 中序遍历
def inorder_traversal(node):
    ls = []
    while True:
        # 节点不为空时
        while node:
            # 入栈
            ls.append(node)
            # 进入左节点
            node = node.left
        # 栈为空时退出
        if ls == []:
            break
        # 出栈
        node = ls.pop()
        print('%3s' % node, end='')
        # 进入右节点
        node = node.right
# 后序遍历，难度较大，以后再补充
def postorder_traversal(node):
    pass
# traversal
ls = [chr(i) for i in range(65, 91)]
fbt = FBT(ls)
print('\npreorder')
preorder_traversal(fbt.nodes[0])
print('\ninorder')
inorder_traversal(fbt.nodes[0])

打印结果同上，不作重复

4、层序遍历

from collections import deque
# 层序遍历
def level_order(node):
    print('\nlevel order')
    # 根节点入队
    q = deque([node])
    # 先进先出
    while q:
        node = q.popleft()
        print('%3s' % node, end='')
        if node.left:
            q.append(node.left)
        if node.right:
            q.append(node.right)
# traversal
level_order(fbt.nodes[0])

打印结果

level order
  A  B  C  D  E  F  G  H  I  J  K  L  M  N  O  P  Q  R  S  T  U  V  W  X  Y  Z

5、探索树的深度

# 树深度,递归法
def depth(node):
    if node is None:
        return 0
    dl = depth(node.left)
    dr = depth(node.right)
    return max(dl, dr) + 1
# the depth of tree
print('the depth of tree:', depth(fbt.nodes[0]))

打印结果

the depth of tree: 5

6、遍历指定层

from collections import deque
# 层序遍历
def level_order(node, layer=2):
    print('\nlevel order')
    # 根节点入队
    q = deque([(node, 1)])
    # 先进先出
    while q:
        node, depth = q.popleft()
        if depth == layer:
            print('%3s' % node, end='')
        if node.left:
            q.append((node.left, depth + 1))
        if node.right:
            q.append((node.right, depth + 1))
# traversal
level_order(fbt.nodes[0], layer=5)

打印结果

level order
  P  Q  R  S  T  U  V  W  X  Y  Z