最近参加一个打卡活动，来学习数据结构（入门级别），记录一下学习笔记（很多参数书上的代码，不喜勿喷）。
（1）冒泡算法
# 冒泡算法：
def bubbleSort(alist):
for i in range(len(alist)-1,0,-1):
for j in range(i):
if alist[j]>alist[j+1]:
temp=alist[j]
alist[j]=alist[j+1]
alist[j+1]=temp冒泡排序通常被认为是最低效的排序方法，因为它必须在最终位置被知道之前交换项。 这些“浪费”的交换操作是非常昂贵的。 然而，因为冒泡排序遍历列表的整个未排序部分，它有能力做大多数排序算法不能做的事情。特别地，如果在遍历期间没有交换，则我们知道该列表已排序。 如果发现列表已排序，可以修改冒泡排序提前停止。这将大大的提高效率---短冒泡排序。
def shortBubbleSort(alist):
exchange=True
passnum=len(alist)-1
while passnum> 0 and exchange:
exchange=False
for i in range (passnum):
if alist[i]>alist[i+1]:
exchange=True
temp=alist[i]
alist[i]=alist[i+1]
alist[i+1]=temp
passnum=passnum-1（2）选择排序
选择排序改进了冒泡排序，每次遍历列表只做一次交换。为了做到这一点，一个选择排序在他遍历时寻找最大的值，并在完成遍历后，将其放置在正确的位置。与冒泡排序一样，在第一次遍历后，最大的项在正确的地方。 第二遍后，下一个最大的就位。遍历 n-1 次排序 n 个项，因为最终项必须在第（n-1）次遍历之后。
def selectionSort(alist):
for fillslot in range(len(alist)-1,0,-1):
#最大位置
positionOfMax=0
for location in range(1,fillslot+1):
if alist[location]>alist[positionOfMax]:
positionOfMax=location
temp=alist[fillslot]
alist[fillslot]=alist[positionOfMax]
alist[positionOfMax]=temp（3）插入排序
插入排序的最大比较次数是 n-1 个整数的总和。同样，是 O(n^2 )。然而，在最好的情况下，每次通过只需要进行一次比较。
def insertSort(alist):
for index in range(1,len(alist)):
currentvalue=alist[index]
posistion=index
while posistion>0 and alist[posistion-1]>currentvalue:
alist[posistion]=alist[posistion-1]
posistion=posistion-1
alist[posistion]=currentvalue（4）希尔排序
希尔排序（有时称为“递减递增排序”）通过将原始列表分解为多个较小的子列表来改进插入排序，每个子列表使用插入排序进行排序。 选择这些子列表的方式是希尔排序的关键。不是将列表拆分为连续项的子列表，希尔排序使用增量i（有时称为 gap ），通过选择 i 个项的所有项来创建子列表。
def shellSort(alist):
sublistcount=len(alist)//2
while sublistcount>0:
for startposition in range(sublistcount):
gapInsertionSort(alist,startposition,sublistcount)
print("After increments of size",sublistcount,"The list is",alist)
sublistcount=sublistcount//2
def gapInsertionSort(alist,start,gap):
for i in range(start+gap,len(alist),gap):
currentvalue=alist[i]
position=i
while position>=gap and alist[position-gap]>currentvalue:
alist[position]=alist[position-gap]
position=position-gap
alist[position]=currentvalue
（5）归并排序
归并排序是一种递归算法，不断将列表拆分为一半。 如果列表为空或有一个项，则按定义（基本情况）进行排序。如果列表有多个项，我们分割列表，并递归调用两个半部分的合并排序。 一旦对这两半排序完成，就执行称为合并的基本操作。合并是
获取两个较小的排序列表并将它们组合成单个排序的新列表的过程。
def mergeSort(alist):
print("Splitting ",alist)
if len(alist)>1:
mid = len(alist)//2
lefthalf = alist[:mid]
righthalf = alist[mid:]
mergeSort(lefthalf)
mergeSort(righthalf)
i=0
j=0
k=0
while i < len(lefthalf) and j < len(righthalf):
if lefthalf[i] < righthalf[j]:
alist[k]=lefthalf[i]
i=i+1
else:
alist[k]=righthalf[j]
j=j+1
k=k+1
while i < len(lefthalf):
alist[k]=lefthalf[i]
i=i+1
k=k+1
while j < len(righthalf):
alist[k]=righthalf[j]
j=j+1
k=k+1
print("Merging ",alist)(6)快速排序
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):
pivotvalue = alist[first]
leftmark = first+1
rightmark = last
done = False
while not done:
while leftmark <= rightmark and alist[leftmark] <= pivotvalue:
leftmark = leftmark + 1
while alist[rightmark] >= pivotvalue and rightmark >= leftmark:
rightmark = rightmark -1
if rightmark < leftmark:
done = True
else:
temp = alist[leftmark]
alist[leftmark] = alist[rightmark]
alist[rightmark] = temp
temp = alist[first]
alist[first] = alist[rightmark]
alist[rightmark] = temp
return rightmark