一、排序
1.冒泡排序
def bubbleSort(theSeq):
for i in range(len(theSeq) - 1):
for j in range(i + 1, len(theSeq)):
if theSeq[i] > theSeq[j]:
theSeq[i], theSeq[j] = theSeq[j], theSeq[i]
return theSeq
2.选择排序
def selectionSort(theSeq):
n = len(theSeq)
for i in range(n - 1):
smallNdx = i
for j in range(i + 1, n):
if theSeq[j] < theSeq[smallNdx]:
smallNdx = j
if smallNdx != i:
theSeq[i], theSeq[smallNdx] = theSeq[smallNdx], theSeq[i]
return theSeq
3.插入排序
def insertionSort(theSeq):
n = len(theSeq)
for i in range(1, n):
value = theSeq[i]
pos = i
while pos > 0 and value < theSeq[pos - 1]:
theSeq[pos] = theSeq[pos - 1]
pos -= 1
theSeq[pos] = value
return theSeq
4、合并排序
(1)
def MergeSort(theList):
if len(theList) <= 1:
return theList
else:
mid = len(theList) // 2
leftHalf = MergeSort(theList[:mid])
rightHalf = MergeSort(theList[mid:])
newList = mergeSortedLists(leftHalf, rightHalf)
return newList
def mergeSortedLists(listA, listB):
newList = list()
a = 0
b = 0
while a < len(listA) and b < len(listB):
if listA[a] < listB[b]:
newList.append(listA[a])
a += 1
else:
newList.append(listB[b])
b += 1
while a < len(listA):
newList.append(listA[a])
a += 1
while b < len(listB):
newList.append(listB[b])
b += 1
return newList
(2)
def MergeSort(theSeq):
n = len(theSeq)
tmpArray = Array(n)
recMergeSort(theSeq, 0, n-1, tmpArray)
def recMergeSort(theSeq, first, last, tmpArray):
# Check the base case: the virtual sequence contains a single item.
if first == last:
return
else:
mid = (first + last) // 2
# Split the sequence and perform the recursive step.
recMergeSort(theSeq, first, mid, tmpArray)
recMergeSort(theSeq, mid+1, last, tmpArray)
# Merge the two ordered subsequences.
mergeVirtualSeq(theSeq, first, mid+1, last+1, tmpArray)
def mergeVirtualSeq(theSeq, left, right, end, tmpArray):
# Merges the two sorted virtual subsequences: [left..right) [right..end)
# using the tmpArray for intermediate storage.
a = left
b = right
# Initialize an index variable for the resulting merged array.
m = 0
# Merge the two sequences together until one is empty.
while a < right and b < end:
if theSeq[a] < theSeq[b]:
tmpArray[m] = theSeq[a]
a += 1
else:
tmpArray[m] = theSeq[b]
b += 1
m += 1
while a < right:
tmpArray[m] = theSeq[a]
a += 1
m += 1
while b < end:
tmpArray[m] = theSeq[b]
b += 1
m += 1
# Copy the sorted subsequence back into the original sequence structure.
for i in range(end - left):
theSeq[i+left] = tmpArray[i]
5、快速排序
(1)
def quickSort(theSeq):
n = len(theSeq)
recQuickSort(theSeq, 0, n-1)
def recQuickSort(theSeq, first, last):
if first >= last:
return
else:
pivot = theSeq[first]
pos = partitionSeq(theSeq, first, last)
recQuickSort(theSeq, first, pos - 1)
recQuickSort(theSeq, pos + 1, last)
def partitionSeq(theSeq, first, last):
pivot = theSeq[first]
left = first + 1
right = last
while left <= right:
while left < right and theSeq[left] < pivot:
left += 1
while right >= left and theSeq[right] >= pivot:
right -= 1
if left < right:
theSeq[left], theSeq[right] = theSeq[right], theSeq[left]
if right != first:
theSeq[first] = theSeq[right]
theSeq[right] = pivot
return right
(2)
# Sorts a sequence of positive integers using the radix sort algorithm.
from llistqueue import Queue
from array import Array
def radixSort(intList, numDigits):
# Create an array of queues to represent the bins.
binArray = Array(10)
for k in range(10):
binArray[k] = Queue()
column = 1
for _ in range(numDigits):
for key in intList:
digit = (key // column) % 10
binArray[digit].enqueue(key)
i = 0
for bin in binArray:
while not bin.isEmpty():
intList[i] = bin.dequene()
i += 1
column *= 10
6.给链表排序
（1）插入排序
class ListNode:
def __init__(self, data):
self.data = data
self.next = None
def llistInsertionSort(origList):
# Make sure the list contains at least one node.
if origList is None:
return None
# Iterate through the original list.
newList = None
while origList is not None:
# Assign a temp reference to the first node.
curNode = origList
# Advance the original list reference to the next node.
origList = origList.next
# Unlink the first node and insert into the new ordered list.
curNode.next = None
newList = addToSortedList(newList, curNode.data)
# Return the list reference of the new ordered list.
return newList
# 这个其实就是链表那一节的insert()函数
def addToSortedList(head, value):
predNode = None
curNode = head
while curNode is not None and value > curNode.data:
predNode = curNode
curNode = curNode.next
newNode = ListNode(value)
newNode.next = curNode
if curNode is head:
head = newNode
else:
predNode.next = newNode
return head
（2）合并排序
def llistMergeSort(theList):
if theList is None:
return None
elif theList.next == None:
return theList
# Split the linked list into two sublists of equal size.
else:
rightList = _splitLinkedList(theList)
leftList = theList
leftList = llistMergeSort(leftList)
rightList = llistMergeSort(rightList)
# Merge the two ordered sublists.
theList = _mergeLinkedLists(leftList, rightList)
# Return the head pointer of the ordered sublist.
return theList
# Splits a linked list at the midpoint to create two sublists.
# The head reference of the right sublist is returned.
# The left sublist is still referenced by the original head reference.
def _splitLinkedList(subList):
# Assign a reference to the first and second nodes in the list.
midPoint = subList
curNode = midPoint.next
# Iterate through the list until curNode falls off the end.
while curNode is not None:
curNode = curNode.next
if curNode is not None:
midPoint = midPoint.next
curNode = curNode.next
# Set rightList as the head pointer to the right sublist.
rightList = midPoint.next
# Unlink the right sub list from the left sublist.
midPoint.next = None
return rightList
def _mergeLinkedLists(subListA, subListB):
# Create a dummy node and insert it at the front of the list.
newList = ListNode(None)
newTail = newList
# Append nodes to the new list until one list is empty.
while subListA is not None and subListB is not None:
if subListA.data <= subListB.data:
newTail.next = subListA
subListA = subListA.next
else:
newTail.next = subListB
subListB = subListB.next
newTail = newTail.next
newTail.next = None
# If self list contains more terms, append them.
if subListA is not None:
newTail.next = subListA
else:
newTail.next = subListB
# Return the new merged list, which begins with the first node after the dummy node.
return newList.next
二、搜索
1.二分法搜索
def binarySearch(theValues, target):
low = 0
high = len(theValues) - 1
while low <= high:
mid = (high + low) // 2
# Does the midpoint contain the target?
if theValues[mid] == target:
return True
# Or does the target precede the midpoint?
elif target < theValues[mid]:
high = mid - 1
# Or does it follow the midpoint?
else:
low = mid + 1
# If the sequence cannot be subdivided further, we're done.
return False
来源：CSDN
作者：qq_45812711
链接：https://blog.csdn.net/qq_45812711/article/details/104017051