目錄

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

結果