Sechs Sortieralgorithmen: Einfügungssortierung, Hill-Sortierung, Auswahlsortierung, Blasensortierung, Heap-Sortierung, Schnellsortierung
1. Einfügungssortierung
1. Beginnend mit dem ersten Element kann davon ausgegangen werden, dass das Element sortiert wurde.
2. Nehmen Sie das nächste Element tem und scannen Sie die sortierte Elementsequenz von hinten nach vorne.
3. Wenn das Element größer als tem ist, verschieben Sie es Element zum nächsten Eins-
Bit 4. Wiederholen Sie Schritt 3, bis Sie in den sortierten Elementen ein Element finden, das kleiner oder gleich tem ist.
5. tem wird hinter dem Element eingefügt. Wenn alle sortierten Elemente größer als tem sind, fügen Sie tem ein in die Position mit Index 0
6. Wiederholen Sie die Schritte 2 bis 5
und der Animationseffekt ist wie folgt:
Idee:
Unter den zu sortierenden Elementen fügen Sie nun unter der Annahme, dass die ersten n-1 Elemente in der richtigen Reihenfolge sind, das n-te Element in das vorherige ein Reihenfolge angeordnet, so dass die ersten n Die Elemente sind geordnet. Fügen Sie alle Elemente nach dieser Methode ein, bis die gesamte Sequenz in Ordnung ist.
Da wir jedoch nicht sicher sind, welcher Teil der zu sortierenden Elemente in Ordnung ist, können wir zunächst nur davon ausgehen, dass das erste Element in Ordnung ist, und die folgenden Elemente der Reihe nach in diese geordnete Reihenfolge einfügen, bis die gesamte Reihenfolge in Ordnung ist .
Die C++-Code-Demo lautet wie folgt:
void InsertSort(int* arr, int n)
{
//这是待插入的元素下标
for (int i = 1; i < n; i++)
{
//这是已经排序好数组的下标
for (int j = i - 1; j >= 0; j--)
{
//如果待排序数字大于，则向后移动
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
else
{
break;
}
}
}
//排序结果输出
for (int i = 0; i < n; i++)
{
cout << arr[i] << " ";
}
}
Zeitkomplexität: O(N*N) im schlimmsten Fall, wenn die zu sortierende Spalte in umgekehrter Reihenfolge oder nahezu umgekehrt ist; im besten Fall ist es O(N) und die zu sortierende Spalte ist es in aufsteigender Reihenfolge oder nahezu aufsteigender Reihenfolge.
Raumkomplexität: O(1)
2. Auswahlsortierung
Idee: Wählen Sie jedes Mal einen Mindestwert aus der zu sortierenden Spalte aus und platzieren Sie ihn dann am Anfang der Sequenz, bis alle zu sortierenden Daten erschöpft sind.
Tatsächlich können wir in einem Durchgang zwei Werte auswählen, einen Maximalwert und einen Minimalwert, und sie dann am Anfang und am Ende der Sequenz platzieren, was die Effizienz der Auswahlsortierung verdoppeln kann.
Der Animationseffekt ist wie folgt:
C++-Code-Implementierung:
void SelectSort(int* arr, int n)
{
//开始从第一个元素进行选择排序
for (int i = 0; i < n-1; i++)
{
//最小值下标暂存变量
int min = i;
//依次从待排序区域取出数据与准备排序的数据进行比较，并暂存最小值下标
for (int j = i+1; j < n; j++)
{
//如果大于，则设置暂存变量
if (arr[min] > arr[j])
{
min = j;
}
}
//与找到的最小值下标互换数据
int temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
//排序结果输出
for (int i = 0; i < n; i++)
{
cout << arr[i] << " ";
}
}
Zeitkomplexität: Schlimmster Fall: O(N^2)
Bester Fall: O(N^2)
Raumkomplexität: O(1)
3. Blasensortierung
Idee:
Die linke Seite ist größer als die rechte Seite und der größte befindet sich auf der rechten Seite. usw.
Die Animation sieht wie folgt aus:
Der C++-Code lautet wie folgt:
void BubbleSort(int * arr, int len)
{
//如果数组为空或者只有一个数组，则返回
if (arr == NULL || len<2)
{
return;
}
//记录是否存在交换，如果不存在，则说明数组已经有序，直接退出，结束排序
bool flag = false;
//如果有两个以上的元素时，则开始排序
//循环外圈
for (int i = len ; i > 0; i--)
{
for (int j = 0; j < len; j++)
{
//如果大于，则交换
if (arr[j] > arr[j+1])
{
arr[j + 1] = arr[j + 1] ^ arr[j];
arr[j] = arr[j + 1] ^ arr[j];
arr[j + 1] = arr[j + 1] ^ arr[j];
flag = true;
}
}
if (!flag)
break;
else
flag = false;
}
//显示排序结果
for (int i = 0; i < len; i++)
{
cout << arr[i] << endl;
}
}
Zeitkomplexität: Schlimmster Fall: O(N^2)
Bester Fall: O(N)
Raumkomplexität: O(1)
Viertens: Sortierung zusammenführen
Ideen:
1. Teilen Sie zuerst das Array auf