Introduction of Selective Sorting
Selection sort is a simple and intuitive sorting algorithm. Firstly, the smallest (large) element is found in the unordered sequence and stored at the beginning of the ordered sequence. Then, the smallest (large) element is searched from the remaining unordered elements and placed at the end of the ordered sequence. By analogy, until all elements are sorted.
The main advantage of selective sorting is related to data movement. If an element is in the right final position, it will not be moved. Select sort to swap a pair of elements each time, at least one of them will be moved to its final position, so sorting the list of n elements will be done for a total of n-1 swaps. Among all sorting methods that rely entirely on swapping to move elements, selective sorting is a very good one.
2. Principle of Selective Sorting
- Find the smallest (large) element in the unordered sequence and store it at the beginning of the ordered sequence
- Continue to find the smallest (largest) element from the remaining unordered elements
- Then put it at the end of the sorted sequence. By analogy, until all elements are sorted.
3. Graphics of Selective Sorting
4. Summary of Selection and Sorting
- With N data, you need to select N-1 times from the unsorted area and put them at the end of the queue in the sorted area.
- Each time the data selected from the unsorted area is placed at the end of the sorted queue
5. python Code Implementation of Selective Sorting
# Define Selective Sorting Function def selection_sort(list): # Calculate the number of list elements that need to be sorted N = len(list) # Need N-1 Secondary selection operation for i in range(N-1): # A small scale for recording minimum values minNum_index = i # Unordered regions from i+1 tctl eof N Where, belongs to the unordered region, where the minimum value is selected in the unordered region for j in range(i+1,N): # Compare size if list[minNum_index]>list[j]: #exchange temp = list[minNum_index] list[minNum_index] = list[j] list[j] = temp # Create a list numList = [19,2,13,8,34,25,7] print("Before sorting:%s"%numList) # Call Selection Sorting selection_sort(numList) print("After sorting:%s"%numList)
The results are as follows:
Before sorting: [19, 2, 13, 8, 34, 25, 7] After sorting: [2, 7, 8, 13, 19, 25, 34]
6. Implementation of Selective Sorting in C Language Code
Version 1
#include <stdio.h> //Define Selective Sorting Function void selection_sort(int array[],int arrayLenght) { // Need N-1 Secondary selection operation for (int i=0; i<arrayLenght-1; i++) { // Subscription of record minimum int minNum_index = i; // Unordered regions from i+1 tctl eof N Where, belong to the unordered region, and then select the minimum value in the unordered region. for (int j = i+1; j<arrayLenght; j++) { // Compare size if (array[minNum_index]>array[j]) { // exchange int temp = array[minNum_index]; array[minNum_index] = array[j]; array[j] = temp; } } } } int main(int argc, const char * argv[]) { // Selection sort function declaration void selection_sort(int array[],int arrayLenght); // Create arrays int numArray[] = {19,2,13,8,34,25,7}; // Call Sorting selection_sort(numArray, 7); // Verification for (int i =0; i<7; i++) { printf("%d ",numArray[i]); } return 0; }
The results are as follows:
2 7 8 13 19 25 34
Version 2
#include <stdio.h> //Define Selective Sorting Function void selection_sort1(int array[],int arrayLenght) { // Need N-1 Secondary selection operation for (int i=0; i<arrayLenght-1; i++) { // Subscription of record minimum int minNum_index = i; // Unordered regions from i+1 tctl eof N Where, belong to the unordered region, and then select the minimum value in the unordered region. for (int j = i+1; j<arrayLenght; j++) { // Compare size if (array[minNum_index]>array[j]) { minNum_index = j; } } if (minNum_index != i) { int temp = array[i]; array[i] = array[minNum_index]; array[minNum_index] = temp; } } } int main(int argc, const char * argv[]) { // Selection sort function declaration void selection_sort1(int array[],int arrayLenght); // Create arrays int numArray[] = {19,2,13,8,34,25,7}; // Call Sorting selection_sort1(numArray, 7); // Verification for (int i =0; i<7; i++) { printf("%d ",numArray[i]); } return 0; }
The results are as follows:
2 7 8 13 19 25 34
Seventh, Time Complexity of Selective Sorting
- Optimal time complexity: O(n2)
- Worst-case time complexity: O(n2)
8. Stability of Selective Sorting
Selective sorting is to select the smallest current element for each location, such as the smallest one for the first location, the second smallest one for the remaining elements, and so on, until the n-1 element, the n-th element does not need to be selected, because only one of its largest elements is left. Then, in a single selection, if an element is smaller than the current element, and the small element appears behind an element equal to the current element, then stability is destroyed after exchange. For example, sequence 58529, we know that the first selection of the first element 5 will be exchanged with 2, then the relative order of the two 5 in the original sequence will be destroyed, so the selection sorting is an unstable sorting algorithm.