Python数据结构：BF算法匹配括号回文链表生成螺旋矩阵移除列表元素计算后缀表达式的值顺时针旋转n维矩阵90度折半查找

Posted 2022-01-26 小星博博

目录

BF算法匹配字符串

匹配括号

回文链表

生成螺旋矩阵

移除列表元素

计算后缀表达式的值

顺时针旋转n维矩阵90度

折半查找

---

BF算法匹配字符串

BF算法：通过模式串T，与目标串S匹配，查找S中是否存在模式串T；

实现思路：通过目标串S的下标取出元素与模式串下标取出元素进行依次比较，如果发生不匹配，则模式串的下标归零，目标串S指向下一个索引。

要求：输出匹配目标串的第一个下标位，不匹配输出-1

代码：

def bf(st, tem):
    i = j = 0
    while i < len(st) and j < len(tem):
        if st[i] == tem[j]:
            j += 1
        else:
            j = 0
        i += 1
    if j == len(tem):
        return i - len(tem)
    else:
        return -1


if __name__ == '__main__':
    print(bf('asdfasdx', 'dx'))

 结果：

匹配括号

匹配括号：输入小括号，中括号，大括号，判断是否匹配

实现思路：先定义一个字典存储括号，以后括号为键“),],”，前括号为值“(,[,”，再把键和值分别放入到新的列表中存储，使用栈的思想来匹配，通过下标取出的括号串的每一个元素，判断是键还是值，如果是值，也就是前括号，则进栈，如果是键则判断当前栈顶元素是否与之匹配，不匹配直接结束程序。

代码：

def match(s):
    assert len(s) > 0
    b = ')': '(', ']': '[', '': ''
    k = b.keys()
    v = b.values()
    l = []
    for i in s:
        if i in v:
            l.append(i)
        elif i in k:
            if len(l) == 0 or l[-1] is not b.get(i):
                return False
            l.pop()
    return len(l) == 0


if __name__ == '__main__':
    print(match(input()))

结果：

回文链表

回文单链表：回文，12321则为回文，正读倒读都一样，判断链表是否是回文的，首先找到单链表的中点，获取中点采用快慢指针法，慢指针移动1格，快指针移动2格，当快指针到最大索引时，慢指针刚好到中点，把单链表的后半段逆置，再与前半段进行比较即可。

要求：输入字符串，中间使用一个空格间隔，转换为单链表，判断是否是回文链表

代码：

class LinkNode:
    def __init__(self, d):
        self.data = d,
        self.next = None


def get_l(s):
    s = list(map(int, s.split(" ")))
    l = LinkNode(0)
    p = l  # 引用传递
    for i in range(len(s)):
        p.next = LinkNode(s[i])
        p = p.next
    return l.next


def palindrom(l):
    if l is None:
        return True;
    s = f = l
    while f.next is not None and f.next.next is not None:
        s = s.next
        f = f.next.next
    h = s.next
    q = reverser(h)
    s.next = None
    p = l
    while p is not None and q is not None:  # p和q都能为空，q为空循环完毕
        if p.data == q.data:
            p, q = p.next, q.next
        else:
            return False
    if q is None:  # q为空说明循环完毕了，说明匹配了
        return True
    return False


# 逆置链表
def reverser(h):
    l = LinkNode(0)
    p = h
    while p is not None:
        x = p.next  # 保存当前项的指向
        p.next = l.next  # 当前项指向头结点的指向
        l.next = p  # 当前项指向头结点指向
        p = x
    return l.next


if __name__ == '__main__':
    l = get_l(input())
    print(palindrom(l))

结果：

生成螺旋矩阵

螺旋矩阵：[1,2,3],[8,9,4],[7,6,5]

代码

#生成螺旋矩阵,如下
# [1,2,3]
# [8,9,4]
# [7,6,5]
def spiral(n):
    matrix = [[0] * n for _ in range(n)]
    # 顺时针方向（右,下,左,上）
    dx = [0, 1, 0, -1]
    dy = [1, 0, -1, 0]
    x = y = 0
    dn = 0  # 方向指针0；向右填充，1：向下填充，2：向上填充，3：向上填充

    for i in range(1, n * n + 1):  # 从1开始赋值，一直到n*n
        matrix[x][y] = i
        temp_x = x + dx[dn]
        temp_y = y + dy[dn]
        if 0 <= temp_x < n and 0 <= temp_y < n and matrix[temp_x][temp_y] == 0:
            x = temp_x
            y = temp_y
        else:
            dn = (dn + 1) % 4
            x += dx[dn]
            y += dy[dn]

    return matrix



if __name__ == '__main__':
    n = int(input("输入矩阵n值："))
    matrix = spiral(n)
    for i in range(n):
        print(matrix[i])

结果

移除列表元素

代码：

# 输入一个列表lt,判断val是否在lt中，如果在，将其删除，最后输出删除后的lt和lt的长度

def remove_element(lt, val):
    k = 0
    for i in range(len(lt)):
        if lt[i] != val:
            lt[k] = lt[i]
            k += 1
    return k


if __name__ == '__main__':
    lt = list(map(int, input().split(' ')))
    val = int(input())
    k = remove_element(lt, val)
    print(k)  # 移除后的元素长度
    print(' '.join(map(str, lt[:k])))  # 输出移除后的新列表： lt[:k]，从0开始截取，截取k位

结果：

计算后缀表达式的值

代码：

def get_value(lt):
    op = []
    i = 0
    while i < len(lt):
        opv = lt[i]
        if opv == "-":
            a, b = op.pop(), op.pop()
            op.append(b - a)
        elif opv == "+":
            a, b = op.pop(), op.pop()
            op.append(a + b)
        elif opv == "*":
            a, b = op.pop(), op.pop()
            op.append(a * b)
        elif opv == "/":
            a, b = op.pop(), op.pop()
            op.append(b / a)
        else:
            op.append(lt[i])
        i += 1
    else:
        return op[-1]


if __name__ == '__main__':
    lt = [56, 20, '-', 4, 2, '+', '/']
    print(get_value(lt))

结果：

顺时针旋转n维矩阵90度

把n维矩阵顺时针旋转90度

代码：

# 先对角线交换，再垂直交换
# [[2,3,4],
# [5,6,7],
# [8,9,1]]
# 翻转90度为
# [[8,5,2],
# [9,6,3],
# [1,7,4]]
# 1先对角线翻转为
# [[2,5,8],
# [3,6,9],
# [4,7,1]]
# 2再水平翻转
# [[8,5,2],
# [9,6,3],
# [1,7,4]]
# 4*4
# [[8,5,2,9],
#  [9,6,3,8],
#  [1,7,4,4],
#  [1,7,4,4]]

# 几层矩阵值，矩阵
def rotatin(n, matrix):
    mat = matrix
    # 对角线翻转
    # 0,0 0,1<=>1,0 0,2<=>2,0
    for i in range(n):
        for j in range(n - i):
            mat[i][j + i], mat[j + i][i] = mat[j + i][i], mat[i][j + i]
    # 水平翻转
    for x in range(n):
        for y in range(n // 2):  # 第一个与倒数第一个交换
            mat[x][y], mat[x][-y - 1] = mat[x][-y - 1], mat[x][y]
    return mat


if __name__ == '__main__':
    n = int(input("输入矩阵数："))
    # matrix = [[2, 3, 4],
    #           [5, 6, 7],
    #           [8, 9, 1]]
    matrix = []
    for i in range(n):
        lt = list(map(int, input("第" + str(i + 1) + "行矩阵：").split(" ")))
        matrix.append(lt)
    matr = rotatin(n, matrix)
    for i in range(n):
        for j in range(n):
            if j == n - 1:
                print(matr[i][j], end="")
            else:
                print(matr[i][j], end="  ")
        print()

结果：

折半查找

折半查找：找出中点值（使用low=0和hight=n-1组成一个区间），判断查询值比中点索引值大还是小，如果小，则把高指针移动到low~mid这个区间里，再进行判断，重复进行即可。

要求：输出差查找到的位置，找不到输出-1

代码

# 折半查找
def BinSearch(R, k):
    n = len(R)
    low, high = 0, n - 1
    while low <= high:
        mid = (low + high) // 2
        if k == R[mid]:
            return mid
        if k < R[mid]:
            high = mid - 1
        else:
            low = mid + 1
    return -1


if __name__ == '__main__':
    x = list(map(int, input().split(" ")))
    print(BinSearch(x, 3))

结果