tail 查找 lis elf 二分查找 結構 __init__ sort partition

這裏整理的都是基礎的不能再基礎的算法，目的就是進行一個回憶，同時作為劍指offer的一個補充~嘿嘿~

查找算法
二分查找
# 實現一個二分查找
# 輸入:一個順序list
# 輸出: 待查找的元素的位置
def binarySearch(alist, item):
first = 0
last = len(alist) - 1

while first <= last:
mid = (first + last)//2
print(mid)
if alist[mid] > item:
last = mid - 1
elif alist[mid] < item:

first = mid + 1
else:
return mid+1
return -1

test = [0, 1, 2, 8, 13, 17, 19, 32, 42]
print(binarySearch(test, 3))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
排序算法
冒泡排序
def bubbleSort(alist):
for passnum in range(len(alist)-1, 0, -1):
for i in range(passnum):
if alist[i] > alist[i+1]:

alist[i], alist[i+1] = alist[i+1], alist[i]
return alist
1
2
3
4
5
6
插入排序
def insertionSort(alist):
for index in range(1, len(alist)):
currentvalue = alist[index]
position = index

while position > 0 and alist[position-1] > currentvalue:
alist[position] = alist[position-1]

position -= 1
alist[position] = currentvalue
1
2
3
4
5
6
7
8
9
快速排序
def quickSort(alist):
quickSortHelper(alist, 0, len(alist)-1)

def quickSortHelper(alist, first, last):
if first < last:
splitPoint = partition(alist, first, last)

quickSortHelper(alist, first, splitPoint-1)
quickSortHelper(alist, splitPoint+1, last)

def partition(alist, first, last):
pivotvlue = alist[first]

leftmark = first+1
rightmark = last
done = False

while leftmark > rightmark:
while alist[leftmark] <= pivotvlue and leftmark <= rightmark:
leftmark += 1
while alist[rightmark] >= pivotvlue and rightmark >= leftmark:
rightmark -= 1
alist[leftmark], alist[rightmark] = alist[rightmark], alist[leftmark]
alist[rightmark], alist[first] = alist[first], alist[rightmark]
return rightmark
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
選擇排序
def selectionSort(alist):
for i in range(len(alist)-1):
min = i
for j in range(i+1, len(alist)):
if alist[j] < alist[min]:
min = j
alist[i], alist[min] = alist[min], alist[i]
return alist
1
2
3
4
5
6
7
8
9
冒泡排序
class Solution:
def bubbleSort(nums):
# 這個循環負責設置冒泡排序進行的次數
for i in range(len(nums)-1):
# ｊ為列表下標
for j in range(len(nums)-i-1):
if nums[j] > nums[j+1]:
nums[j], nums[j+1] = nums[j+1], nums[j]
return nums
1
2
3
4
5
6
7
8
9
樹的四種遍歷方式
class node(object):
def __init__(self,data=None,left=None,right=None):
self.data=data
self.left=left
self.right=right

#深度
def depth(tree):
if tree==None:
return 0
left,right=depth(tree.left),depth(tree.right)
return max(left,right)+1
#前序遍歷
def pre_order(tree):
if tree==None:
return
print tree.data
pre_order(tree.left)
pre_order(tree.right)
#中序遍歷
def mid_order(tree):
if tree==None:
return
mid_order(tree.left)
print tree.data
mid_order(tree.right)
#後序遍歷
def post_order(tree):
if tree==None:
return
post_order(tree.left)
post_order(tree.right)
print tree.data

#層次遍歷
def level_order(tree):
if tree==None:
return
q=[]
q.append(tree)
while q:
current=q.pop(0)
print current.data
if current.left!=None:
q.append(current.left)
if current.right!=None:
q.append(current.right)
---------------------
作者：alicelmx
來源：CSDN
原文：https://blog.csdn.net/alicelmx/article/details/80429229
版權聲明：本文為博主原創文章，轉載請附上博文鏈接！

【python】面試常考數據結構算法