Python面试一百题——算法（2）

目录

1. 删除链表中重复的节点
2. 二叉搜索树的第k个节点
3. 字符串循环左移k位
4. 整数区间中1出现的次数
5. 二叉树中和为某一值的路径
6. 青蛙跳台阶（斐波那契）
7. 用递归的方法绘制带绿叶的小树
8. 绘制谢尔宾斯基三角形

0.1删除链表中重复的节点

class LinkedNode:
    def __init__(self, x):
        self.val = x
        self.next = None

def delete(pHead):
    nodeValue = {}
    newHead = LinkedNode(pHead.val)
    nodeValue[pHead.val] = pHead.val

    curNode = newHead
    while pHead.next:
        pHead = pHead.next
        if nodeValue.get(pHead.val) == None:
            curNode.next = LinkedNode(pHead.val)
            curNode = curNode.next
            nodeValue[pHead.val] = pHead.val
    return newHead

header = LinkedNode(5)
node1 = LinkedNode(5)
header.next = node1
node2 = LinkedNode(10)
node1.next = node2
node3 = LinkedNode(3)
node2.next = node3

def printLinked(header):
    p = header
    while p:
        print(p.val, end=' ')
        p = p.next

header1 = delete(header)
printLinked(header1)	# 5 10 3

0.2二叉搜索树的第k个节点

中序遍历

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class KNode:
    def KthNode(self, pRoot, k):
        global result
        result = []
        middle = self.midorder(pRoot)
        if k <= 0 or len(middle) < k:
            return None
        else:
            return middle[k - 1]

    def midorder(self, pRoot):
        if not pRoot:
            return []
        self.midorder(pRoot.left)
        result.append(pRoot)
        self.midorder(pRoot.right)
        return result

root = TreeNode(10)
left = TreeNode(6)
right = TreeNode(15)
root.left = left
root.right = right

left1 = TreeNode(11)
right1 = TreeNode(20)
right.left = left1
right.right = right1

print(KNode().KthNode(root, 4).val)
15

0.3字符串循环左移k位

def leftmove(s, k):
    return s[k:] + s[:k]

def rightmove(s, k):
    return s[len(s) - k:] + s[:len(s) - k]
print(leftmove('abcXYZopq', 3))		# XYZopqabc
print(rightmove('abcXYZopq', 3))	# opqabcXYZ

0.4整数区间中1出现的次数

def findone(n):
    count = 0
    for i in range(1, n+1):
        for i in str(i):
            if i == '1':
                count +=1
    return count

print(findone(200))
140

0.5二叉树中和为某一值的路径

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

def findpath(root, n):
    if not root:
        return []
    result = []
    def findpath2(root, path, curNum):
        curNum += root.val
        path.append(root)
        # 判断root是否为叶子节点
        flag = root.left == None and root.right == None

        if curNum == n and flag:
            onepath = []
            for node in path:
                onepath.append(node.val)
            result.append(onepath)
        if curNum < n:
            if root.left:
                findpath2(root.left, path, curNum)
            if root.right:
                findpath2(root.right, path, curNum)
        path.pop()
    findpath2(root, [], 0)
    return result

root = TreeNode(10)
left = TreeNode(6)
right = TreeNode(15)
root.left = left
root.right = right

left1 = TreeNode(11)
right1 = TreeNode(20)
right.left = left1
right.right = right1

print(findpath(root, 16))
[[10, 6]]

0.6青蛙跳台阶（斐波那契数列）

'''
总共 n 级台阶，剩下 f(n) 级
1.第一次跳 1 级，剩下 f(n-1) 级
2.第一次跳 2 级，剩下 f(n-2) 级
第一次跳就这两个方法，总共 f(n-1) + f(n-2) 种方法
f(1) = 1
f(2) = 2
斐波那契数列
'''
def jumpfloor(n):
    res = [1, 2]
    while len(res) <= n:
        res.append(res[-1] + res[-2])
    if n == 1:
        return 1
    else:
        return res[n - 1]

print(jumpfloor(20))
10946

0.7用递归的方法绘制带绿叶的小树

import turtle

def tree(branch_len, t):
    if branch_len > 5:
        # 绘制树干
        t.forward(branch_len)
        if (branch_len - 15) <= 5:
            t.pencolor('green')
        else:
            t.pencolor('black')
        # 改变树干粗细
        new_width = branch_len // 5
        if new_width > 0:
            t.pensize(new_width)

        # 向右旋转20度
        t.right(20)
        tree(branch_len - 15, t)   # 每绘制一次树干长度减小15
        if new_width > 0:
            t.pensize(new_width)
        # 绘制左侧
        t.left(40)
        tree(branch_len - 15, t)
        t.right(20)
        t.backward(branch_len)

t = turtle.Turtle()
win = turtle.Screen()
t.left(90)  # 从下到上画
t.pencolor('black')
t.pensize(15)
tree(70, t)
win.exitonclick()

0.8绘制谢尔宾斯基三角形

import turtle

# 绘制三角形
# points [[x1, y1], [x2, y2], [x3, y3]]
def draw_triangle(points, color, t):
    t.fillcolor(color)
    t.up()
    # 将画笔移动到第一个点
    t.goto(points[0][0], points[0][1])
    t.down()
    t.begin_fill()
    t.goto(points[1][0], points[1][1])
    t.goto(points[2][0], points[2][1])
    t.goto(points[0][0], points[0][1])
    t.end_fill()

# 计算中间点
def mid_point(p1, p2):
    return ((p1[0] + p2[0])/2, (p1[1] + p2[1])/2)

def sterpin(points, degree, t):
    color = ['blue', 'green', 'red', 'yellow', 'orange', 'violet']
    # 绘制大的三角形
    draw_triangle(points, color[degree], t)
    if degree >= 0:
        # 绘制左下角三角形
        sterpin([points[0], mid_point(points[0], points[1]), mid_point(points[0], points[2])], degree - 1, t)
        # 绘制上方三角形
        sterpin([points[1], mid_point(points[0], points[1]), mid_point(points[1], points[2])], degree - 1, t)
        # 绘制右下角三角形
        sterpin([points[2], mid_point(points[2], points[1]), mid_point(points[0], points[2])], degree - 1, t)

t = turtle.Turtle()
win = turtle.Screen()
points = [[-200, -100], [0, 200], [200, -100]]
sterpin(points, 4, t)
win.exitonclick()