Algorithm classification

Ten common sorting algorithms can be divided into two categories:

Comparative sorting : The relative order of elements is determined by comparison. Because its time complexity cannot exceed O(nlogn), it is also called nonlinear time comparison sorting.
Non-comparative sorting : The relative order between elements is not determined by comparison. It can break through the lower bound of time based on comparative sorting and run in linear time, so it is also called linear-time non-comparative sorting.

Algorithm complexity

Related concepts

Stable : If a is originally in front of b, and a=b, a is still in front of b after sorting.
Unstable : If a is originally in front of b, and a=b, a may appear behind b after sorting.
Time complexity : the total number of operations on sorted data. Reflects the law of the number of operations when n changes.
Space complexity: refers to the algorithm in the computer

A measure of the storage space required for internal execution, which is also a function of the data size n.

1. Bubble Sort (Bubble Sort)

Bubble sort is a simple sorting algorithm. It has repeatedly visited the sequence to be sorted, comparing two elements at a time, and swapping them if they are in the wrong order. The work of visiting the sequence is repeated until no more exchanges are needed, which means that the sequence has been sorted. The origin of the name of this algorithm is because the smaller the element will slowly "float" to the top of the sequence through exchange.

1.1 Algorithm description

Compare adjacent elements. If the first one is larger than the second, swap the two;
Do the same work for each pair of adjacent elements, from the first pair at the beginning to the last pair at the end, so that the last element should be the largest number;
Repeat the above steps for all elements except the last one;
Repeat steps 1~3 until the sorting is completed.

1.2 Animation demo

1.3 code implementation

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

const int maxn = 100;
int arr[maxn], length;

//设置随机数组
void setRandArray(int a[]) {
	srand((unsigned)time(NULL));
	for (int i = 0; i < length; i++) {
		int j = rand() % 100;
		a[i] = j;
	}
}

//输出数组
void showArray(int* a) {
	cout << "数组元素内容：";
	for (int i = 0; i < length; i++) {
		cout << a[i] << " ";
	}
	cout << endl;
}

//冒泡排序
void bubbleSort(int *arr) {
	for (int i = 0; i < length - 1; i++) {
		for (int j = 0; j < length - 1 - i; j++) {
			if (arr[j] > arr[j + 1]) {
				int temp = arr[j + 1];
				arr[j + 1] = arr[j];
				arr[j] = temp;
			}
		}
	}
}

int main()
{
	cout << "输入元素个数：";
	cin >> length;
	setRandArray(arr);
	showArray(arr);
	bubbleSort(arr);
	cout << "冒泡排序后的数组：" << endl;
	showArray(arr);
	return 0;
}

2. Selection Sort (Selection Sort)

Selection-sort (Selection-sort) is a simple and intuitive sorting algorithm. Its working principle: first find the smallest (large) element in the unsorted sequence, store it at the beginning of the sorted sequence, and then continue to find the smallest (large) element from the remaining unsorted elements, and then put it in the sorted sequence At the end. And so on, until all elements are sorted.

2.1 Algorithm description

The direct selection and sorting of n records can be directly selected and sorted through n-1 times to obtain an ordered result. The specific algorithm is described as follows:

Initial state: the disordered area is R[1..n], and the ordered area is empty;
At the beginning of the i-th sorting (i=1,2,3...n-1), the current ordered area and disordered area are R[1..i-1] and R(i..n) respectively. This sorting trip selects the record R[k] with the smallest key from the current disordered area, and exchanges it with the first record R of the disordered area to make R[1..i] and R[i+1 ..n) Become a new ordered area with the number of records increased by one and a new disordered area with the number of records decreased by one;
At the end of n-1 pass, the array is ordered.

2.2 Moving picture demonstration

2.3 Code implementation

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

const int maxn = 100;
int arr[maxn], length;

//设置随机数组
void setRandArray(int a[]) {
	srand((unsigned)time(NULL));
	for (int i = 0; i < length; i++) {
		int j = rand() % 100;
		a[i] = j;
	}
}

//输出数组
void showArray(int* a) {
	cout << "数组元素内容：";
	for (int i = 0; i < length; i++) {
		cout << a[i] << " ";
	}
	cout << endl;
}

//选择排序
void selectionSort(int arr[]) {
	int minIndex, temp;
	for (int i = 0; i < length - 1; i++) {
		minIndex = i;
		for (int j = i + 1; j < length; j++) {
			if (arr[j] < arr[minIndex]) {
				minIndex = j;
			}
		}
		temp = arr[i];
		arr[i] = arr[minIndex];
		arr[minIndex] = temp;
	}
}

int main()
{
	cout << "输入元素个数：";
	cin >> length;
	setRandArray(arr);
	showArray(arr);
	selectionSort(arr);
	showArray(arr);
	return 0;
}

3. Insertion Sort (Insertion Sort)

The algorithm description of Insertion-Sort is a simple and intuitive sorting algorithm. Its working principle is to construct an ordered sequence. For unsorted data, scan from back to front in the sorted sequence, find the corresponding position and insert.

3.1 Algorithm description

Generally speaking, insertion sort is implemented on the array using in-place. The specific algorithm is described as follows:

Starting from the first element, the element can be considered to have been sorted;
Take out the next element and scan from back to front in the sorted sequence of elements;
If the element (sorted) is larger than the new element, move the element to the next position;
Repeat step 3 until you find the position where the sorted element is less than or equal to the new element;
After inserting the new element into this position;
Repeat steps 2~5.

3.2 Motion Picture Demonstration

3.2 Code implementation

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

const int maxn = 100;

//设置随机数组
void setRandArray(int a[], int length) {
	srand((unsigned)time(NULL));
	for (int i = 0; i < length; i++) {
		int j = rand() % 100;
		a[i] = j;
	}
}

//输出数组
void showArray(int* a, int length) {
	cout << "数组元素内容：";
	for (int i = 0; i < length; i++) {
		cout << a[i] << " ";
	}
	cout << endl;
}

//插入排序
void insertionSort(int *arr,int len){
	int preIndex,current;
	for(int i = 1; i < len; i++){
		preIndex = i - 1;
		current = arr[i];
		while(preIndex >= 0 && arr[preIndex] > current){
			arr[preIndex + 1] = arr[preIndex];
			preIndex--;
		}
		arr[preIndex + 1] = current;
	}
} 

int main()
{
	int arr[maxn], length;
	cout << "数组元素个数：";
	cin >> length;
	setRandArray(arr,length);
	showArray(arr,length);
	insertionSort(arr,length);
	showArray(arr,length);
	return 0;
}

4. Hill sorting (Shell Sort)

Shell invented in 1959, the first sorting algorithm to break O(n2), which is an improved version of simple insertion sort. The difference between it and insertion sort is that it will compare the farther elements first. Hill sorting is also called reduced incremental sorting .

4.1 Algorithm description

First divide the entire sequence of records to be sorted into several sub-sequences for direct insertion sorting, the specific algorithm description:

Choose an incremental sequence t1, t2,..., tk, where ti>tj, tk=1;
Sort the sequence k times according to the number of increment sequences k;
In each sorting pass, according to the corresponding increment ti, the sequence to be sorted is divided into several sub-sequences of length m, and each sub-table is directly inserted and sorted. Only when the increment factor is 1, the entire sequence is treated as a table, and the length of the table is the length of the entire sequence.

First, it divides the larger data set into several groups (logically grouped), and then inserts and sorts each group separately. At this time, the amount of data used by the insertion sort is relatively small (each group), and the efficiency of insertion Relatively high