4가지 정렬 알고리즘: 버블, 삽입, 선택, 고속

버블 정렬

기본 사상

정렬할 요소의 열을 반복적으로 방문하여 인접한 두 요소를 차례로 비교하고 순서(예: 큰 것에서 작은 것, 첫 글자 A에서 Z로)가 잘못된 경우 교환합니다. 요소를 방문하는 작업은 인접한 요소를 교환할 필요가 없을 때까지, 즉 요소 열이 정렬될 때까지 반복됩니다. 버블정렬 1회 통과 후 가장 큰(가장 작은) 숫자가 끝에 붙기 때문에 2회째 버블정렬 1회 통과의 마지막 숫자와 비교할 필요가 없다.

C++ 코드

#include<iostream>
using namespace std;
// 声明冒泡排序算法（参数含义：1.数组 2.数组尺寸）
void BubbleSort(int arr[], int n);
// 声明打印算法
void PrintArr(int arr[], int n);

int main()
{
    
    
	// 数组例子
	int arr[] = {
    
     2, 3, 4, 1, 5, 6, 2, 8, 9 };
	// 数组大小
	int n = sizeof(arr) / sizeof(int);
	// 冒泡排序
	BubbleSort(arr, n);
	PrintArr(arr, n);
	return 0;
}
// 冒泡排序实现
void BubbleSort(int arr[], int n)
{
    
    
	int i, j;
	for (i = 0; i < n - 1; i++)
	{
    
    
		for (j = 0; j < n - 1 - i; j++)
		{
    
    
			// 交换
			if (arr[j + 1] < arr[j])
			{
    
    
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}
// 打印算法实现
void PrintArr(int arr[], int n)
{
    
    
	for (int i = 0; i < n; i++)
	{
    
    
		cout << arr[i] << " ";
	}
	cout << endl;
}

시간복잡도와 공간복잡도

시간복잡도 O(n^2)
공간복잡도 O(1) 공간복잡도는 보조기억물이 존재하는지를 알아보기 위한 것인데 임시변수 temp가 있어서 둘을 교환할 때 사용한다. 강요. 실제로 공간 복잡도는 O(0)으로 줄일 수 있으며 교환 코드를 다음과 같이 변경합니다.

a = a + b;
b = a - b;
a = a - b;

다만, 이런 식으로 범위를 벗어나는 문제가 있을 수 있으므로 임시 변수는 정직하게 사용하는 것이 좋습니다.

삽입 정렬

기본 사상

오름차순 또는 내림차순 순서를 왼쪽에서 오른쪽으로 단계적으로 구축합니다. 정렬되지 않은 데이터의 경우 정렬된 데이터에서 점진적으로 적절한 위치를 찾아
이전에 정렬된 배열에 현재 키 값을 삽입하여 정렬합니다. 배열, 이 주기는 삽입 정렬
은 작은 규모의 데이터나 기본적으로 순서가 있는 데이터에 적용할 때 효율적이지만,
규모가 크고 순서가 없는 데이터의 경우에는 삽입정렬이 비효율적이어서 시행해야 함 개선점, 힐정렬 가능 이 효과

C++ 코드

#include<iostream>
using namespace std;
// 声明插入排序算法（参数：1.数组 2.数组大小）
void InsertSort(int arr[], int n);
// 声明打印方法
void PrintArr(int arr[], int n);

int main()
{
    
    
	// 例子数组
	int arr[] = {
    
     4, 4, 6, 1, 7, 8, 23, 15, 9, 2 };
	// 数组大小
	int n = sizeof(arr) / sizeof(int);
	InsertSort(arr, n);
	PrintArr(arr, n);
	return 0;
}
// 插入排序实现
void InsertSort(int arr[], int n)
{
    
    
	int i, j, key;
	for (i = 0; i < n; i++)
	{
    
    
		// 选择当前为key的值插入i之前排序好的数组中，让其也变为排序好的数组
		key = arr[i];
		j = i - 1;
		while (j >= 0 && arr[j] > key)
		{
    
    
			arr[j + 1] = arr[j];
			j--;
		}
		arr[j + 1] = key;
	}
}
// 打印输出方法实现
void PrintArr(int arr[], int n)
{
    
    
	for (int i = 0; i < n; i++)
	{
    
    
		cout << arr[i] << "  ";
	}
	cout << endl;
}

시간복잡도와 공간복잡도

시간복잡도: O(n^2)
공간복잡도: O(0), 교환에는 임시변수 temp가 없습니다.

선택 정렬

기본 사상

1차적으로 정렬할 데이터 요소 중에서 가장 작은(또는 가장 큰) 요소를 선택하여 시퀀스의 시작 부분에 저장한 다음 나머지 정렬되지 않은 요소에서 가장 작은(또는 가장 큰) 요소를 찾아 배치합니다. 정렬된 순서의 끝. 정렬할 모든 데이터 요소의 수가 0이 될 때까지 계속됩니다.

C++ 코드

#include<iostream>
#include<iomanip>
using namespace std;

void SelectSort(int arr[], int n);//选择排序
void EnterArr(int arr[], int n);
void PrintArr(int arr[], int n);

int main()
{
    
    
	int arr[10] = {
    
     7, 6, 8, 2, 1, 4, 0, 9, 2, 3 }; 
	int n = 10;
	SelectSort(arr, n);
	cout << "排好序后:";
	PrintArr(arr, n);
	return 0;
}

void SelectSort(int arr[], int n)
{
    
    
	int i, j, min, temp;
	for (i = 0; i < n - 1; i++)
	{
    
    
		min = i;
		for (j = i + 1; j < n; j++)
		{
    
    
			if (arr[min] > arr[j])
			{
    
    
				min = j;
			}
		}
		if (i != min)
		{
    
    
			temp = arr[min];
			arr[min] = arr[i];
			arr[i] = temp;
		}
	}
}

void EnterArr(int arr[], int n)
{
    
    
	for (int i = 0; i < n; i++)
	{
    
    
		cin >> arr[i];
	}
}

void PrintArr(int arr[], int n)
{
    
    
	for (int i = 0; i < n; i++)
	{
    
    
		cout << arr[i] << " ";
	}
	cout << endl;
}

시간복잡도와 공간복잡도

시간복잡도 : O(n^2)
공간복잡도 : O(1) 임시변수 temp가 있기 때문

빠른 정렬

기본 사상

정렬할 데이터를 원패스 정렬로 두 개의 독립적인 부분으로 나누고 한 부분의 모든 데이터가 다른 부분의 모든 데이터보다 작은 다음 이 방법에 따라 데이터의 두 부분을 신속하게 정렬합니다. 정렬 프로세스는 재귀적일 수 있으므로 전체 데이터가 정렬된 시퀀스가 ​​됩니다.

C++ 코드

#include<iostream>
using namespace std;
void Qsort(int arr[], int low, int high);//快速排序
int main()
{
    
    
	int arr[10] = {
    
     7, 6, 8, 2, 1, 4, 0, 9, 2, 3 }; 
	int n = 10;
	Qsort(arr, 0, sizeof(arr) / sizeof(int) - 1);
	cout << "排好序后:";
	PrintArr(arr, n);
	return 0;
}
void Qsort(int arr[], int low, int high)//快速排序
{
    
    
	if (high <= low)
	{
    
    
		return;
	}
		
	int i = low;
	int j = high + 1;
	int key = arr[low];
	while (true)
	{
    
    
		//从左往右找比key大的值
		while (arr[++i] < key)
		{
    
    
			if (i == high)
			{
    
    
				break;
			}
		}
		//从右往左找比key小的值
		while (arr[--j] > key)
		{
    
    
			if (j == low)
			{
    
    
				break;
			}
		}
		if (i >= j)
		{
    
    
			break;
		}
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
	//中枢值与j对应的值交换
	int temp = arr[low];
	arr[low] = arr[j];
	arr[j] = temp;
	// 左边递归快排
	Qsort(arr, low, j - 1);
	// 右边递归快排
	Qsort(arr, j + 1, high);
}
void PrintArr(int arr[], int n)
{
    
    
	for (int i = 0; i < n; i++)
	{
    
    
		cout << arr[i] << " ";
	}
	cout << endl;
}

시간복잡도와 공간복잡도

시간 복잡도: 최상의 경우: O(nlogn), 최악의 경우: O(n^2), 평균: O(nlogn)
공간 복잡도: O(logn)