sorting algorithms

Bubble Sorting is a simple sort. In this sort, the "Bubble Policy" is used to move the maximum element to the rightmost. During the bubble process, two adjacent elements are compared. If the left side is greater than the right side, two elements are exchanged. After such a bubble, you can ensure that the maximum is on the rightmost side. Then, execute n bubbles and then sort them. The program code is as follows: // BubbleSort. cpp: defines the entry p

# Include After sorted... 1 2 3 4 5 6 Reference: Introduction to Algorithms Insert sorting of sorting algorithms

Insert sorting of sorting algorithms # Include Using namespace std; int arrSort [6] = {5, 2, 4, 6, 1, 3}; void insert_sort_asc (int arr [], int arrCount) {int key; int j; for (int I = 1; I = 0 (arr [j]> key) {arr [j + 1] = arr [j]; j --;} // while arr [j + 1] = key;} // for} int main () {insert_sort_asc (arrSort, 6); cout After sorted... 1

Quick sorting void quick_sort(int array[], int begin, int end){if(end > begin){int pivot = begin;int last_small = begin;int i = end;while(last_small != i){if(array[i] Heap sorting void adjust_heap(int[], int, int);void build_heap(int array[], int size)//build the max-heap{for(int i = size - 1; i >= 0; i--){adjust_heap(array, size, i);}}void adjust_heap(int array[], int size, int element)//adjust the max

# Include /* Select sorting Basic Idea: Find the smallest one from the back and put it to the last one sorted in the front. Features: time complexity O (N ^ 2) */ Void selectsort (INT array [], int N ){ Int I, J; Int temp = 0, flag = 0; For (I = 0; I Temp = array [I]; Flag = I; For (j = I + 1; j If (array [J] Temp = array [J]; Flag = J; } } // Avoid assigning values. In extreme cases, values 1, 2, 3, 4, and 5 are ordered. If (flag! = I ){ Arra

Sixth chapter Heap SortingMinimum heap and maximum heap: approximate complete binary treeA[parent (i)]Build heap complexity O (n)Sort O (NLGN)In practical applications, fast sorting is generally better than heap sorting. Can be used for priority queues and so on.In a heap containing n elements, all priority queue operations can be done in O (LGN) time.Seventh Chapter Quick SortDivide and conquer the same so

1. Summary of the complexity of internal sorting1) Complexity of timeThe average time complexity of 4 sorts is O (nlog2n), "Get back Faster with nlog2n" (Fast, hill Sort, merge, heap sort)In the worst case, the time complexity of the n*n is O (2) Complexity of spaceO (log2n) Quick-lineO (n) MergeO (RD) CardinalityAll the others are O (1)3) StabilityUnstable: "Review the pain Ah, emotional instability, quickly choose a bunch of friends to chat" (Quick row, hill, simple selection

Read some of the code written in introduction to algorithms and make a record. # Include

Select a stable Sorting Algorithm for sorting, fast sorting, Hill sorting, and heap sorting. Bubble sorting, insert sorting, Merge Sorting,

Sorting and sorting algorithms -- Sorting problems, such as numbers 1, 2, 3, 4, 5, and 6 -- ideas: (1) if 1 is changed to 5, that is, 1 is directly changed to, 2, 3, 4, and 5, respectively, minus 1 and 6 unchanged -- (2) if 5 is changed to 3, 5 is directly changed to and 2, 3, 4 minus 1, 6 unchanged -- (3) for example:

is calledInternal sorting(Inner sorting); otherwise, if the data needs to be exchanged between internal and external storage, it is calledExternal sorting.Note:① Inner sorting applies to small files with a small number of records② External sorting is suitable for large files with too many records that cannot be stored

Seven classical sorting algorithms based on python (recommended) and seven types of python I. Basic concepts and classifications of sorting Sorting is an operation that sorts a string of records in ascending or descending order based on the size of one or more keywords. Sorting