Python implements multiple sorting methods
Bubble sort

Overview and Principle
Bubble Sort is a basic sorting algorithm.
Bubble sorting compares two adjacent elements in the list in turn, replacing the order of the adjacent elements according to the sorting method.
To reach the beginning of the list after a round of comparison, make the largest or smallest elements appear as "bubbles", and reach the order list after n rounds of comparison. 
Code implementation (ascending)
def bubble_sort(demo): for i in range(1, len(demo)): # i denotes the number of bubbling wheels for j in range(0,len(demo)i): # j represents the element index for each comparison if demo[j]>demo[j+1]: # Swap when small index elements are larger than large index elements demo[j],demo[j+1] = demo[j+1],demo[j] print(demo) test_list = [0,9,2,5,3,6,1] bubble_sort(test_list) [0, 1, 2, 3, 5, 6, 9] # Output Order List
 Stability and time complexity
 stability
The sorting process does not exchange equal elements when there are equal elements in the list to be sorted, so bubble sorting is a stable sort method.  Time Complexity
For the worst case of sorting, the list to be sorted is completely i n reverse order, which requires n1 rounds of sorting, each round requires ni exchanges, i.e., the average number of exchanges per round n/2, the time complexity is T(n)=n(n1)/2, so the time complexity of bubble sorting is O(n^2);
Select Sort

Overview and Principle
Selection Sort is a basic sorting algorithm.
Select Sort to find the largest or smallest element in the unsorted list and place it at the beginning of the list.
Then select the largest or smallest element in the remaining unsorted list and place it at the beginning of the remaining list until it is sorted completely; 
Code implementation (ascending)
def select_sort(demo): for i in range(len(demo)1): # i indicates the number of rounds to choose min_index = i # min_index represents the index that filters out the smallest elements for j in range(i+1,len(demo)): # j represents the element index for each comparison if demo[j]<demo[min_index]: # When the index of the smallest element J to be compared is updated to j when it is smaller than the known minimum element min_index = j if min_index != i: # If the minimum element index changes after a round of comparison, the minimum element is swapped with the starting position element demo[i],demo[min_index] = demo[min_index],demo[i] print(demo) test_list = [0,9,2,5,3,6,1] select_sort(test_list) [0, 1, 2, 3, 5, 6, 9] # Output Order List
 Stability and time complexity
 stability
When there are equal elements in the list to be sorted, the sorting process exchanges the same elements, such as the list [5(0), 5(1), 1], and then changes to [1,5(1), 5(0)] after a round of selection sorting, so the selection sorting is unstable.  Time Complexity
Selection sort requires n1 rounds of sorting, and ni exchange operations are needed i n each round, i.e. n/2 of average exchange times per round, then the time complexity is T(n)=n(n1)/2, so the time complexity of selection sort is O(n^2);
Insert Sort

Overview and Principle
Insert Sort is a basic sorting algorithm.
Insert Sort selects the first element in the unsorted list to compare with the sorted list element in turn, and substitutes it according to the sort until it is inserted in the appropriate place, that is, into the sorted list;
Then insert the first element in the remaining unsorted list, and then complete the sorting of all elements. 
Code implementation (ascending)
def insert_sort(demo): for i in range(1,len(demo)): # i indicates the number of rounds to insert for j in range(i,0,1): # j means the index of the element to be compared, starting at the end of the sorted list if demo[j]<demo[j1]: demo[j],demo[j1] = demo[j1],demo[j] else: break print(demo) print(demo) test_list = [0,9,2,5,3,6,1] insert_sort(test_list) [0, 1, 2, 3, 5, 6, 9] # Output Order List
 Stability and time complexity
 stability
When there are equal elements in the list to be sorted, the sorting process exchanges the same elements, such as the list [5', 5,1], and after a round of selection sorting becomes [1,5,5'], so the selection sorting is unstable.  Time Complexity
Selection sort requires n1 rounds of sorting, and ni exchange operations are needed i n each round, i.e. n/2 of average exchange times per round, then the time complexity is T(n)=n(n1)/2, so the time complexity of selection sort is O(n^2);
Quick Sort

Overview and Principle
Quick Sort is an improvement on the bubble sort algorithm.
First, select an element in the unordered list as the base value element, and divide the list to be sorted into two parts through a round of sorting.
All data in one part is smaller than the base value element, and all data in the other part is larger than the base value.
Then the two parts of the unordered list are sorted rapidly by recursion idea, and the whole list is sorted in order. 
Code implementation (ascending)
def quick_sort(demo): if len(demo) > 1: # Sort lists when they are longer than 1 mid = demo[len(demo) // 2] # Select the base element, this example selects the middle value as the base element left, right = [], [] # Initialize empty list on left and right sides of base element demo.remove(mid) # Remove base elements from the original list for i in demo: # Iterate through the list elements in turn, with values less than the base element in the left list and values greater than the base element in the right list left.append(i) if i < mid else right.append(i) return quick_sort(left) + [mid] + quick_sort(right) # Return to sorted list else: return demo # Recursive end condition is that the list to be sorted has only one element test_list = [0,9,2,5,3,6,1] test_list = quick_sort(test_list) print(test_list) [0, 1, 2, 3, 5, 6, 9] # Output Order List
 Stability and time complexity
 stability
When there are equal elements in the list to be sorted, the sorting process exchanges the same elements, such as the list [6,5', 5,1,7], the base value 5, and the sorting becomes [1,5,5', 6,7], so the quick sorting is an unstable sorting method.  Time Complexity
Quick sorting only correctly ranks one element at a time. The average number of swaps per round of sorting is n/2, and the time complexity is T(n)=n(n1)/2, so the time complexity of quick sorting is O(n^2);