編程題

1 臺階問題/斐波那契

一只青蛙一次可以跳上1級臺階，也可以跳上2級。求該青蛙跳上一個n級的臺階總共有多少種跳法。

fib = lambda n: n if n <= 2 else fib(n - 1) + fib(n - 2)

第二種記憶方法

def memo(func):

cache = {}

def wrap(*args):

if args not in cache:

cache[args] = func(*args)

return cache[args]

return wrap

@memo

def fib(i):

if i < 2:

return 1

return fib(i-1) + fib(i-2)

第三種方法

def fib(n):

a, b = 0, 1

for _ in xrange(n):

a, b = b, a + b

return b

2 變態臺階問題

一只青蛙一次可以跳上1級臺階，也可以跳上2級……它也可以跳上n級。求該青蛙跳上一個n級的臺階總共有多少種跳法。

fib = lambda n: n if n < 2 else 2 * fib(n - 1)

3 矩形覆蓋

我們可以用2*1的小矩形橫著或者豎著去覆蓋更大的矩形。請問用n個2*1的小矩形無重疊地覆蓋一個2*n的大矩形，總共有多少種方法？

第2*n個矩形的覆蓋方法等于第2*(n-1)加上第2*(n-2)的方法。

f = lambda n: 1 if n < 2 else f(n - 1) + f(n - 2)

4 楊氏矩陣查找

在一個m行n列二維數組中，每一行都按照從左到右遞增的順序排序，每一列都按照從上到下遞增的順序排序。請完成一個函數，輸入這樣的一個二維數組和一個整數，判斷數組中是否含有該整數。

使用Step-wise線性搜索。

def get_value(l, r, c):

return l[r][c]

def find(l, x):

m = len(l) - 1

n = len(l[0]) - 1

r = 0

c = n

while c >= 0 and r <= m:

value = get_value(l, r, c)

if value == x:

return True

elif value > x:

c = c - 1

elif value < x:

r = r + 1

return False

5 去除列表中的重復元素

用集合

list(set(l))

用字典

l1 = ['b','c','d','b','c','a','a']

l2 = {}.fromkeys(l1).keys()

print l2

用字典并保持順序

l1 = ['b','c','d','b','c','a','a']

l2 = list(set(l1))

l2.sort(key=l1.index)

print l2

列表推導式

l1 = ['b','c','d','b','c','a','a']

l2 = []

[l2.append(i) for i in l1 if not i in l2]

sorted排序并且用列表推導式.

l = ['b','c','d','b','c','a','a'] [single.append(i) for i in sorted(l) if i not in single] print single

6 鏈表成對調換

1->2->3->4轉換成2->1->4->3.

class ListNode:

def __init__(self, x):

self.val = x

self.next = None

class Solution:

# @param a ListNode

# @return a ListNode

def swapPairs(self, head):

if head != None and head.next != None:

next = head.next

head.next = self.swapPairs(next.next)

next.next = head

return next

return head

7 創建字典的方法

1 直接創建

dict = {'name':'earth', 'port':'80'}

2 工廠方法

items=[('name','earth'),('port','80')]

dict2=dict(items)

dict1=dict((['name','earth'],['port','80']))

3 fromkeys()方法

dict1={}.fromkeys(('x','y'),-1)

dict={'x':-1,'y':-1}

dict2={}.fromkeys(('x','y'))

dict2={'x':None, 'y':None}

8 合并兩個有序列表

知乎遠程面試要求編程

尾遞歸

def _recursion_merge_sort2(l1, l2, tmp):

if len(l1) == 0 or len(l2) == 0:

tmp.extend(l1)

tmp.extend(l2)

return tmp

else:

if l1[0] < l2[0]:

tmp.append(l1[0])

del l1[0]

else:

tmp.append(l2[0])

del l2[0]

return _recursion_merge_sort2(l1, l2, tmp)

def recursion_merge_sort2(l1, l2):

return _recursion_merge_sort2(l1, l2, [])

循環算法

思路：

定義一個新的空列表

比較兩個列表的首個元素

小的就插入到新列表里

把已經插入新列表的元素從舊列表刪除

直到兩個舊列表有一個為空

再把舊列表加到新列表后面

def loop_merge_sort(l1, l2):

tmp = []

while len(l1) > 0 and len(l2) > 0:

if l1[0] < l2[0]:

tmp.append(l1[0])

del l1[0]

else:

tmp.append(l2[0])

del l2[0]

tmp.extend(l1)

tmp.extend(l2)

return tmp

pop彈出

a = [1,2,3,7]

b = [3,4,5]

def merge_sortedlist(a,b):

c = []

while a and b:

if a[0] >= b[0]:

c.append(b.pop(0))

else:

c.append(a.pop(0))

while a:

c.append(a.pop(0))

while b:

c.append(b.pop(0))

return c

print merge_sortedlist(a,b)

9 交叉鏈表求交點

其實思想可以按照從尾開始比較兩個鏈表，如果相交，則從尾開始必然一致，只要從尾開始比較，直至不一致的地方即為交叉點，如圖所示

# 使用a,b兩個list來模擬鏈表，可以看出交叉點是 7這個節點

a = [1,2,3,7,9,1,5]

b = [4,5,7,9,1,5]

for i in range(1,min(len(a),len(b))):

if i==1 and (a[-1] != b[-1]):

print "No"

break

else:

if a[-i] != b[-i]:

print "交叉節點：",a[-i+1]

break

else:

pass

另外一種比較正規的方法，構造鏈表類

class ListNode:

def __init__(self, x):

self.val = x

self.next = None

def node(l1, l2):

length1, lenth2 = 0, 0

# 求兩個鏈表長度

while l1.next:

l1 = l1.next

length1 += 1

while l2.next:

l2 = l2.next

length2 += 1

# 長的鏈表先走

if length1 > lenth2:

for _ in range(length1 - length2):

l1 = l1.next

else:

for _ in range(length2 - length1):

l2 = l2.next

while l1 and l2:

if l1.next == l2.next:

return l1.next

else:

l1 = l1.next

l2 = l2.next

修改了一下:

#coding:utf-8

class ListNode:

def __init__(self, x):

self.val = x

self.next = None

def node(l1, l2):

length1, length2 = 0, 0

# 求兩個鏈表長度

while l1.next:

l1 = l1.next#尾節點

length1 += 1

while l2.next:

l2 = l2.next#尾節點

length2 += 1

#如果相交

if l1.next == l2.next:

# 長的鏈表先走

if length1 > length2:

for _ in range(length1 - length2):

l1 = l1.next

return l1#返回交點

else:

for _ in range(length2 - length1):

l2 = l2.next

return l2#返回交點

# 如果不相交

else:

return

10 二分查找

#coding:utf-8

def binary_search(list, item):

low = 0

high = len(list) - 1

while low <= high:

mid = (high - low) / 2 + low # 避免(high + low) / 2溢出

guess = list[mid]

if guess > item:

high = mid - 1

elif guess < item:

low = mid + 1

else:

return mid

return None

mylist = [1,3,5,7,9]

print binary_search(mylist, 3)

11 快排

#coding:utf-8

def quicksort(list):

if len(list)<2:

return list

else:

midpivot = list[0]

lessbeforemidpivot = [i for i in list[1:] if i<=midpivot]

biggerafterpivot = [i for i in list[1:] if i > midpivot]

finallylist = quicksort(lessbeforemidpivot)+[midpivot]+quicksort(biggerafterpivot)

return finallylist

print quicksort([2,4,6,7,1,2,5])

12 找零問題

#coding:utf-8

#values是硬幣的面值values = [ 25, 21, 10, 5, 1]

#valuesCounts 錢幣對應的種類數

#money 找出來的總錢數

#coinsUsed 對應于目前錢幣總數i所使用的硬幣數目

def coinChange(values,valuesCounts,money,coinsUsed):

#遍歷出從1到money所有的錢數可能

for cents in range(1,money+1):

minCoins = cents

#把所有的硬幣面值遍歷出來和錢數做對比

for kind in range(0,valuesCounts):

if (values[kind] <= cents):

temp = coinsUsed[cents - values[kind]] +1

if (temp < minCoins):

minCoins = temp

coinsUsed[cents] = minCoins

print ('面值:{0}的最少硬幣使用數為:{1}'.format(cents, coinsUsed[cents]))

13 廣度遍歷和深度遍歷二叉樹

給定一個數組，構建二叉樹，并且按層次打印這個二叉樹

14 二叉樹節點

class Node(object):

def __init__(self, data, left=None, right=None):

self.data = data

self.left = left

self.right = right

tree = Node(1, Node(3, Node(7, Node(0)), Node(6)), Node(2, Node(5), Node(4)))

15 層次遍歷

def lookup(root):

row = [root]

while row:

print(row)

row = [kid for item in row for kid in (item.left, item.right) if kid]

16 深度遍歷

def deep(root):

if not root:

return

print root.data

deep(root.left)

deep(root.right)

if __name__ == '__main__':

lookup(tree)

deep(tree)

17 前中后序遍歷

深度遍歷改變順序就OK了

#coding:utf-8

#二叉樹的遍歷

#簡單的二叉樹節點類

class Node(object):

def __init__(self,value,left,right):

self.value = value

self.left = left

self.right = right

#中序遍歷:遍歷左子樹,訪問當前節點,遍歷右子樹

def mid_travelsal(root):

if root.left is not None:

mid_travelsal(root.left)

#訪問當前節點

print(root.value)

if root.right is not None:

mid_travelsal(root.right)

#前序遍歷:訪問當前節點,遍歷左子樹,遍歷右子樹

def pre_travelsal(root):

print (root.value)

if root.left is not None:

pre_travelsal(root.left)

if root.right is not None:

pre_travelsal(root.right)

#后續遍歷:遍歷左子樹,遍歷右子樹,訪問當前節點

def post_trvelsal(root):

if root.left is not None:

post_trvelsal(root.left)

if root.right is not None:

post_trvelsal(root.right)

print (root.value)

18 求最大樹深

def maxDepth(root):

if not root:

return 0

return max(maxDepth(root.left), maxDepth(root.right)) + 1

19 求兩棵樹是否相同

def isSameTree(p, q):

if p == None and q == None:

return True

elif p and q :

return p.val == q.val and isSameTree(p.left,q.left) and isSameTree(p.right,q.right)

else :

return False

20 前序中序求后序

def rebuild(pre, center):

if not pre:

return

cur = Node(pre[0])

index = center.index(pre[0])

cur.left = rebuild(pre[1:index + 1], center[:index])

cur.right = rebuild(pre[index + 1:], center[index + 1:])

return cur

def deep(root):

if not root:

return

deep(root.left)

deep(root.right)

print root.data

21 單鏈表逆置

class Node(object):

def __init__(self, data=None, next=None):

self.data = data

self.next = next

link = Node(1, Node(2, Node(3, Node(4, Node(5, Node(6, Node(7, Node(8, Node(9)))))))))

def rev(link):

pre = link

cur = link.next

pre.next = None

while cur:

tmp = cur.next

cur.next = pre

pre = cur

cur = tmp

return pre

root = rev(link)

while root:

print root.data

root = root.next

22 兩個字符串是否是變位詞

class Anagram:

"""

@:param s1: The first string

@:param s2: The second string

@:return true or false

"""

def Solution1(s1,s2):

alist = list(s2)

pos1 = 0

stillOK = True

while pos1 < len(s1) and stillOK:

pos2 = 0

found = False

while pos2 < len(alist) and not found:

if s1[pos1] == alist[pos2]:

found = True

else:

pos2 = pos2 + 1

if found:

alist[pos2] = None

else:

stillOK = False

pos1 = pos1 + 1

return stillOK

print(Solution1('abcd','dcba'))

def Solution2(s1,s2):

alist1 = list(s1)

alist2 = list(s2)

alist1.sort()

alist2.sort()

pos = 0

matches = True

while pos < len(s1) and matches:

if alist1[pos] == alist2[pos]:

pos = pos + 1

else:

matches = False

return matches

print(Solution2('abcde','edcbg'))

def Solution3(s1,s2):

c1 = [0]*26

c2 = [0]*26

for i in range(len(s1)):

pos = ord(s1[i])-ord('a')

c1[pos] = c1[pos] + 1

for i in range(len(s2)):

pos = ord(s2[i])-ord('a')

c2[pos] = c2[pos] + 1

j = 0

stillOK = True

while j<26 and stillOK:

if c1[j] == c2[j]:

j = j + 1

else:

stillOK = False

return stillOK

print(Solution3('apple','pleap'))

23 動態規劃問題

總結

以上是生活随笔為你收集整理的python 编程算法_python语言编程算法的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。