## 1, Hanoi Tower problem

def hanoi(n,a,b,c): #Move from a through b to c if n>0: hanoi(n-1,a,c,b) #Move from a through b to c print("disc%d moving from %s to %s" %(n,a,c)) hanoi(n-1,b,a,c) #Move from b through a to c hanoi(2,'A','B','C')

The recurrence formula h(x)=2h(x-1)+1 is about equal to the nth power of 2

## 2, Search

### 1. Sequential search

def linear_search(li,val): for ind,v in enumerate(li): if v == val: return ind else: return None

### 2. Dichotomy search

def binary_search(li,val): left = 0 right = len(li) - 1 while left <= right: #Candidate area has value mid = (left + right) // 2 # divide by 2 if li[mid] == val: return mid elif li[mid] > val: #The value to be found is to the left of mid right = mid - 1 else: #The value to be found is to the right of mid left = mid + 1 else: return None #Not found

Time complexity: O(logn)

## 3, Sort

Primary sort:

### 1. Bubble sorting

Sorting in place does not need to occupy new memory space.

Every two adjacent numbers in the list. If the front is larger than the back, exchange these two numbers;

After a sequence is completed, the unordered area decreases by one number and the ordered area increases by one number.

def bubble_sort(li): #Ascending arrangement for i in range(len(li)-1): #The i-th trip starts from 0 exchange = False for j in range(len(li)-i-1): #Pointer, n-i-1 positions per trip if li[j] > li[j+1]: li[j],li[j+1] = li[j+1],li[j] exchange = True print(li) if not exchange: return

Time complexity O(n^2)

### 2. Select sort

The minimum number of records to be sorted in a row is placed in the first position

Once again, sort the smallest number in the unordered area of the record list and put it in the second position

... until the end of sorting

def select_sort(li): for i in range(len(li)-1): #Trip i min_loc = i for j in range(i+1,len(li)): #Traversal range if li[j] < li[min_loc]: #If it is the smallest, save the subscript to min_loc min_loc = j li[i],li[min_loc] = li[min_loc],li[i] #The minimum value and the first number of disordered areas exchange positions print(li)

Time complexity O(n^2)

### 3. Insert sort

At the beginning, there is only one card in your hand (ordered area)

Touch a card from the disordered area each time and insert it into the correct position of the existing card in your hand

def insert_sort(li): for i in range(1,len(li)): #Indicates the subscript of the touched card tmp = li[i] j = i - 1 #j refers to the subscript of the card in hand traversing from right to left while li[j] > tmp and j >= 0: #Until you find a card smaller than the one you touch li[j+1] = li[j] #Move one bit to the right j -= 1 li[j+1] = tmp print(li)

Time complexity O(n^2)

Advanced sort:

### 3. Quick sort

Take the first element p (the first element) and return the element p

The list is divided into two parts by p. the left is smaller than p and the right is larger than p

Recursive completion sorting

def partition(li,left,right):#One time fast sorting of homing function tmp = li[left] while left < right: while left < right and li[right] >= tmp: #From the right, find a number smaller than tmp and put it in the space of left right -= 1 #One to the left li[left] = li[right] #Put the value on the right into the space on the left while left < right and li[left] <= tmp: left += 1 li[right] = li[left] #Put the value on the left into the space on the right li[left] = tmp #Reset the original value return left #Put back mid, that is, the value of left or right def quick_sort(li,left,right): if left < right: #There are at least two elements mid = partition(li,left,right) quick_sort(li,left,mid-1) quick_sort(li,mid+1,right) #Recursive call mid is divided into left and right parts

Time complexity: O(nlogn)

Worst case: O(n^2)

Avoidance method: you can mess up the list first, or select the first number at random instead of the first number

### 4. Heap sort

Storage mode of binary tree: chain storage mode and sequential storage mode

Sequential storage mode:

Parent node i, left child node 2i+1, right child node 2i+2

Child node i, parent node (i-1) // 2

Heap: is a special complete binary tree structure

Large root heap: a complete binary tree that satisfies that any node is larger than its child node

Small root heap: a complete binary tree, satisfying that any node is smaller than its child node

One-time downward adjustment: the left and right subtrees of a node are heaps, but they are not heaps. They can be turned into a heap by one-time downward adjustment

Heap sort process:

(1) Build heap (any node is larger / smaller than its child node)

(2) Start counting by size: get the top element of the heap, which is the largest element

(3) Remove the top of the heap and put the last element of the heap on the top of the heap. At this time, the conditions for one-time downward adjustment are met, and the heap can be reordered through one-time adjustment

(4) The top element is the second largest element

(5) Repeat step 3 until the reactor becomes empty

Build heap:

First look at the last non leaf node and look up layer by layer

def sift(li,low,high): #One time downward adjustment algorithm """ :param li: list :param low: Heap top position of the heap (root node) :param high: Position of the last element of the heap :return: """ i = low #i initially points to the root node j = 2 * i + 1 #j started as a left child tmp = li[low] #Store the top of the pile while j <= high: #Cycle as long as there are several j positions if j+1 <= high and li[j+1] > li[j]: #If the right child is larger than the left child, point j to the right child j = j + 1 #Point j to the right child if li[j] > tmp: li[i] = li[j] #Move the large number to the position of i i = j #i look down one floor j = 2 * i + 1 else: #tmp is bigger. Put tmp at i li[i] = tmp #Put tmp in the position of the parent node of a certain layer break else: li[i] = tmp #j> After high, put the tmp into the leaf node def heap_sort(li): n = len(li) #Build heap for i in range((n-2)//2,-1,-1): #i represents the subscript of the root of the adjusted part when creating the heap, starting from the root node of n-1, in reverse order sift(li,i,n-1) #low is the root node of the adjustment part, and high is placed directly on the last leaf node #Heap building is complete and counting begins for i in range(n-1,-1,-1): #i always points to the last number in the heap li[0],li[i] = li[i],li[0] # The last number is exchanged with the top of the heap sift(li,0,i-1) #Adjust the low of the whole heap to 0, the current last number is i-1, and i-1 is the new high #Sort complete li = [i for i in range(100)] import random random.shuffle(li) print(li) heap_sort(li) print(li)

Time complexity: half the complexity of sift process, which is O(logn); Entire heap sort O(nlogn)

Actual performance: quick sort is better than heap sort

Python heap sorting built-in module: heapq

Common functions:

Heap ify (x): build heap (small root heap)

heappush(heap,item): add elements to heap

heappop(heap): pop up a minimum number at a time

eg:

import heapq #Q - > queue priority queue (small first out / large first out) import random li = [i for i in range(100)] random.shuffle(li) print(li) heapq.heapify(li) #Build pile print(li) for i in range(len(li)): print(heapq.heappop(li),end=',')

topk problem: there are n numbers. Design the algorithm to get the number with the largest top k (k < n)

Solution:

Slice after sorting O(nlogn)

Bubble / insert / select sort O(kn)

Using heap sorting: complexity O(nlogk) is faster

Take the first k elements of the list to create a small root heap, and the top of the heap is the largest number k at present

Traverse the original list backward in turn. If the element in the list is less than the top of the heap, the element is ignored; If it is larger than the top of the heap, replace the top of the heap with this element and adjust the heap once

After traversing all the elements in the list, pop up the top of the heap in reverse order

#topk changes according to heap sort def sift(li,low,high): #One time downward adjustment algorithm """ :param li: list :param low: Heap top position of the heap (root node) :param high: Position of the last element of the heap :return: """ i = low #i initially points to the root node j = 2 * i + 1 #j started as a left child tmp = li[low] #Store the top of the pile while j <= high: #Cycle as long as there are several j positions if j+1 <= high and li[j+1] < li[j]: #If the right child is smaller than the left child, point j to the right child j = j + 1 #Point j to the right child if li[j] < tmp: li[i] = li[j] #Move the small number to the position of i i = j #i look down one floor j = 2 * i + 1 else: #tmp is bigger. Put tmp at i li[i] = tmp #Put tmp in the position of the parent node of a certain layer break else: li[i] = tmp #j> After high, put the tmp into the leaf node def topk(li,k): heap = li[0:k] for i in range((k-2)//2,-1,-1): sift(li,i,k-1) #1. Build pile for i in range(k,len(li)-1): if li[i] > heap[0]: heap[0] = li[i] sift(heap,0,k-1) #2. Traverse all elements for i in range(k-1,-1,-1): heap[0], heap[i] = heap[i], heap[0] sift(heap, 0, i - 1) #3. Count out return heap import random li = list(range(100)) random.shuffle(li) print(topk(li,10))

### 5. Merge sort

One time merge: suppose the list is divided into two ordered segments, which are collectively called a sequential table

Merge sort - use one merge:

(1) Decomposition: divide the list smaller and smaller until it is divided into one element

(2) Termination condition: when there is only one element, it must be ordered

(3) Merge: merge two sequential tables. The list becomes larger and larger

def merge(li,low,mid,high): #The list is divided into two paragraphs i = low j = mid + 1 #Start pointer at both ends ltmp = [] #A temporary list while i <= mid and j <= high: #As long as there are both left and right paragraphs if li[i] < li[j]: ltmp.append(li[i]) i += 1 else: ltmp.append(li[j]) j += 1 #After the while execution, some of the two paragraphs must be numbered while i <= mid: ltmp.append(li[i]) i += 1 while j <= high: ltmp.append(li[j]) j += 1 li[low:high+1] = ltmp #Slice the right package and write the temporary list def merge_sort(li,low,high): if low < high: #There are at least two elements in the segment, recursive mid = (low + high) //2 merge_sort(li,low,mid) merge_sort(li,mid+1,high) merge(li,low,mid,high)

Time complexity: once merge O(n), decompose + merge the whole: O(nlogn)

Space complexity: O(n) opens temporary list storage