コンテンツ
1.コンセプト
1.1並べ替え
並べ替えとは、 1つまたはいくつかのキーワードの サイズに 応じて、一連のレコードを昇順または降順で並べ替える操作です。通常のコンテキストでは、並べ替えについて言及する場合、通常は昇順(降順ではない)を指します。通常の意味でのソートとは、インプレース ソート を指します 。
1.2安定性(重要)
2つの等しいデータ、並べ替えアルゴリズムが並べ替え後に相対位置が変更されないようにすることができる場合、このアルゴリズムを安定並べ替えアルゴリズムと呼びます。(簡単に言えば、数字の文字列には2つの同一のデータがあります。2つのデータ間の位置関係が並べ替え後に変化し ない 場合は安定しています。2つのデータ間の位置関係が変化する場合は不安定です。)
1.3アプリケーション
例:2022.2TOP12 プログラミング言語
2.上位7つの比較ベースの並べ替え-概要
2.1内部ソートと外部ソート
a。内部ソート(メモリ内)
ここでの7つの主要なソートはすべて内部ソートであり、直接挿入ソート、バブルソート、およびマージソートはすべて安定したソートです。
b。外部ソーティング(ハードディスクによって異なります)
バケットソート、基数ソート、カウントソートがあります。時間計算量はO(n)であり、データ要件が非常に高いため、特定の機会に使用する必要があります。
3.7つの主要なランキング
0:トリプルを交換します
(すべてのソートコードは、その後このコードを呼び出す必要があります)
(ソートでは2つの位置を交換する必要があります。これは、ソートで交換が何度も使用されるため、別のメソッドを記述して直接呼び出すためです)
//交换三连
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
1.バブルソート
1.1コンセプト
順序付けされていない間隔では、隣接する番号の比較を通じて、最大の番号が順序付けされていない間隔の最後にバブルされ、このプロセスは、配列が全体として順序付けられるまで続きます。(前から後ろに比較して交換します。大きな数字を配置した後、 各レイヤーは最後の位置に大きな数字を配置します )
1.2実装
//1.冒泡排序
public static void bubbleSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
boolean isSorted = false;
for (int j = 0; j < arr.length - 1; j++) {
if (arr[j] > arr[j + 1]) {
swap(arr, j, j + 1);
//当 isSorted 为 true 时说明当前存在交换
isSorted = true;
}
}
// 当 isSorted 不为 true 时说明当前层不存在交换,数据已经有序,结束循环即可
// 减少时间复杂度
if (!isSorted) {
break;
}
}
}
//交换三连
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
1.3パフォーマンス分析
2.選択ソート
a。一方向オプションの並べ替え
毎回、順序付けされていない間隔から 最大(または最小)の要素を選択し、 並べ替えるすべてのデータ要素がなくなるまで、順序付けされていない間隔の最後(または先頭)に格納します。
//2.1单向选择排序
public static void selectionSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int min = i;
for (int j = i + 1; j < arr.length; j++) {
//遍历当前层剩下的元素,找到最小数的索引
if (arr[min] > arr[j]) {
min = j;
}
}
//将最小数放在当前 i 的位置
swap(arr, min, i);
}
}
//交换三连
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
b。双方向オプションの並べ替え
毎回、順序付けされていない間隔から最小+最大の要素を選択し、並べ替えるすべてのデータ要素がなくなるまで、順序付けされていない間隔の先頭と最後にそれらを格納します。
//2.2双向选择排序
public static void selectionSortOP(int[] arr) {
int low = 0;
int high = arr.length - 1;
// low = high,无序区间只剩下一个元素,数组已经有序
while (low <= high) {
int min = low;
int max = low;
遍历当前层剩下的元素,分别找到最小数和最大数的索引
for (int i = low + 1; i <= high; i++) {
if (arr[min] > arr[i]) {
min = i;
}
if (arr[max] < arr[i]) {
max = i;
}
}
swap(arr, min, low);
if (max == low) {
// 最大值在上一步swap已经被换到min这个位置
max = min;
}
swap(arr, max, high);
low += 1;
high -= 1;
}
}
//交换三连
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
3.直接挿入ソート
a。直接挿入ソート
間隔全体が順序付き間隔と順序なし間隔に分割されます。毎回、順序なし間隔の最初の要素が選択され、順序付き間隔の適切な位置に挿入されます。
// 3.1直接插入排序
// 每次从无序区间中拿第一个值插入到已经排序区间的合适位置,直到整个数组有序
public static void insertionSort(int[] arr) {
// 已排序区间[0,i)
// 待排序区间[i...n]
for (int i = 1; i < arr.length; i++) {
// 待排序区间的第一个元素arr[i]
// 从待排序区间的第一个元素向前看,找到合适的插入位置
for (int j = i; j >= 1 && arr[j] < arr[j - 1]; j--) {
swap(arr, j, j - 1);
}
}
}
//交换三连
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
b。ハーフ挿入ソート
順序付けられた間隔でデータを挿入する位置を選択する場合、間隔の順序が正しいため、検索を半分にするというアイデアを使用できます。
// 3.2直接插入排序(已排序区间两端插入,插入时使用二分法)
public static void insertionSortBS(int[] arr) {
// 有序区间[0..i)
// 无序区间[i...n]
for (int i = 1; i < arr.length; i++) {
int val = arr[i];
int left = 0;
int right = i;
//在有序区间,二分法找到 value 的位置
while (left < right) {
int mid = left + ((right - left) >> 1);
if (val < arr[mid]) {
right = mid;
} else {
// 当val >= arr[mid]
left = mid + 1;
}
}
// 搬移left..i的元素
for (int j = i; j > left; j--) {
arr[j] = arr[j - 1];
}
// left就是val插入的位置
arr[left] = val;
}
}
4.ヒルソート
4.1コンセプト
ヒルソート法は、縮小増分法とも呼ばれます。ヒルソート方法の基本的な考え方は、最初に整数を選択し、ソートするファイル内のすべてのレコードをグループに分割し、距離がのすべてのレコードが同じグループにあり、各グループのレコードをソートすることです。次に、上記のグループ化と並べ替えの作業を繰り返します。= 1に達すると、すべてのレコードが統合グループ内で並べ替えられます。
1. ヒルソートは、 直接挿入ソート の最適化です。2. ギャップ>1の 場合 、事前に並べ替えられます。目的は、配列を順序に近づけることです。ギャップ==1の場合、配列はすでに順序付けに近いため、高速です。このようにして、全体的な最適化効果を達成することができます。実装後のパフォーマンステストを比較できます。
4.2実装
//4.希尔排序
public static void shellSort(int[] arr) {
int gap = (arr.length - 1) >> 2;
while (gap > 0) {
// 按照gap分组进行插入排序
insertionSortByGap(arr, gap);
gap = gap >> 1;
}
}
// 类似于直接插入排序
private static void insertionSortByGap(int[] arr, int gap) {
for (int i = gap; i < arr.length; i++) {
for (int j = i; j - gap >= 0 && arr[j] < arr[j - gap]; j -= gap) {
swap(arr, j, j - gap);
}
}
}
//交换三连
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
4.3パフォーマンス分析
5.ヒープソート
5.1コンセプト
詳細については、こちらの記事「Javaヒープと優先度キュー」を参照してください。
基本的な原則も選択ソートですが、トラバーサルを使用して順序付けされていない間隔の最大数を見つける代わりに、ヒープを使用して順序付けされていない間隔の最大数を選択します。注:大きなヒープは昇順で作成する必要があり、小さなヒープは降順で作成する必要があります。
5.2実装
//5.堆排序
public static void heapSort(int[] arr) {
// 1.先将arr进行heapify调整为最大堆
// 从最后一个非叶子节点开始进行siftDown操作
for (int i = (arr.length - 1 - 1) / 2; i >= 0; i--) {
siftDown(arr, i, arr.length);
}
// 此时arr为最大堆
for (int i = arr.length - 1; i > 0; i--) {
// arr[0] 堆顶元素,就是当前堆的最大值
swap(arr, 0, i);
siftDown(arr, 0, i);
}
}
private static void siftDown(int[] arr, int i, int length) {
while (2 * i + 1 < length) {
int j = (i << 1) + 1;
if (j + 1 < length && arr[j + 1] > arr[j]) {
j = j + 1;
}
// j就是左右子树的最大值
if (arr[i] > arr[j]) {
// 下沉结束
break;
} else {
swap(arr, i, j);
i = j;
}
}
}
//交换三连
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
5.3パフォーマンス分析
6.マージソート
a。マージソート
マージソート( MERGE-SORT )は、 分割統治法(分割統治)の非常に典型的なアプリケーションであるマージ操作に 基づく効果的なソートアルゴリズムです。 順序付けられたサブシーケンスをマージして、完全に順序付けられたシーケンスを取得します。つまり、最初に各サブシーケンスを順序付けし、次にサブシーケンスセグメントを順序付けします。2つの並べ替えられたリストが1つの並べ替えられたリストにマージされる場合、それは双方向マージと呼ばれます。
達成:
//6.归并排序
public static void mergeSort(int[] arr) {
mergeSortInternal(arr, 0, arr.length - 1);
}
//在arr[l...r]进行归并排序,整个arr经过函数后就是一个已经有序的数组
private static void mergeSortInternal(int[] arr, int l, int r) {
if (r - l <= 0) {
return;
}
int mid = l + ((r - l) >> 1);
// 将原数组拆分为左右两个小区间,分别递归进行归并排序
// 走完这个函数之后 arr[l..mid]已经有序
mergeSortInternal(arr, l, mid);
// 走完这个函数之后 arr[mid + 1..r]已经有序
mergeSortInternal(arr, mid + 1, r);
// 1.只有左右两个子区间还有先后顺序不同时才merge
if (arr[mid] > arr[mid + 1]) {
merge(arr, l, mid, r);
}
}
//在arr[l..r]使用插入排序
private static void insertionSort(int[] arr, int l, int r) {
for (int i = l + 1; i <= r; i++) {
for (int j = i; j > l && arr[j] < arr[j - 1]; j--) {
swap(arr, j, j - 1);
}
}
}
//合并两个子数组arr[l..mid] 和 arr[mid + 1...r]
private static void merge(int[] arr, int l, int mid, int r) {
// 先创建一个新的临时数组aux
int[] aux = new int[r - l + 1];
// 将arr元素值拷贝到aux上
for (int i = 0; i < aux.length; i++) {
aux[i] = arr[i + l];
}
// i就是左侧小数组的开始索引
int i = l;
// j就是右侧小数组的开始索引
int j = mid + 1;
// k表示当前正在合并的原数组的索引下标
for (int k = l; k <= r; k++) {
if (i > mid) {
// 左侧区间已经被处理完毕,只需要将右侧区间的值拷贝原数组即可
arr[k] = aux[j - l];
j++;
} else if (j > r) {
// 右侧区间已经被处理完毕,只需要将左侧区间的值拷贝到原数组即可
arr[k] = aux[i - l];
i++;
} else if (aux[i - l] <= aux[j - l]) {
// 此时左侧区间的元素值较小,相等元素放在左区间,保证稳定性
arr[k] = aux[i - l];
i++;
} else {
// 右侧区间的元素值较小
arr[k] = aux[j - l];
j++;
}
}
}
//交换三连
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
b。マージソートの反復書き込み
//6.2归并排序的迭代写法
public static void mergeSortNonRecursion(int[] arr) {
// 最外层循环表示每次合并的子数组的元素个数
for (int sz = 1; sz <= arr.length; sz += sz) {
// 内层循环的变量i表示每次合并的开始索引
// i + sz 就是右区间的开始索引,i + sz < arr.length说明还存在右区间
for (int i = 0; i + sz < arr.length; i += sz + sz) {
merge(arr, i, i + sz - 1, Math.min(i + sz + sz - 1, arr.length - 1));
}
}
}
//合并两个子数组arr[l..mid] 和 arr[mid + 1...r]
private static void merge(int[] arr, int l, int mid, int r) {
// 先创建一个新的临时数组aux
int[] aux = new int[r - l + 1];
// 将arr元素值拷贝到aux上
for (int i = 0; i < aux.length; i++) {
aux[i] = arr[i + l];
}
// i就是左侧小数组的开始索引
int i = l;
// j就是右侧小数组的开始索引
int j = mid + 1;
// k表示当前正在合并的原数组的索引下标
for (int k = l; k <= r; k++) {
if (i > mid) {
// 左侧区间已经被处理完毕,只需要将右侧区间的值拷贝原数组即可
arr[k] = aux[j - l];
j++;
} else if (j > r) {
// 右侧区间已经被处理完毕,只需要将左侧区间的值拷贝到原数组即可
arr[k] = aux[i - l];
i++;
} else if (aux[i - l] <= aux[j - l]) {
// 此时左侧区间的元素值较小,相等元素放在左区间,保证稳定性
arr[k] = aux[i - l];
i++;
} else {
// 右侧区间的元素值较小
arr[k] = aux[j - l];
j++;
}
}
}
7.クイックソート
a。ずっとクイックロー(前後のトラバース)
1. ピボット値 としてソートする範囲から数値を選択します ;2.パーティション: ソートされる間隔全体をトラバースし、参照値よりも小さいもの(equalsを含めることができる)を参照値の左側に配置し、参照値よりも大きいもの(equalsを含めることができる)を参照値の権利;3.分割統治のアイデアを採用し、セルの長さ == 1になるまで、つまりセルの長さ== 0になる まで、左右のセルを同じ方法で処理します。 、これはデータがないことを意味します。
// 取随机数
private static final ThreadLocalRandom random = ThreadLocalRandom.current();
//7.0快速排序
public static void quickSort(int[] arr) {
quickSortInternal(arr, 0, arr.length - 1);
}
private static void quickSortInternal(int[] arr, int l, int r) {
if (r - l <= 0) {
return;
}
// 先获取分区点
// 所谓的分区点就是经过分区函数后,某个元素落在了最终的位置
// 分区点左侧全都是小于该元素的区间,分区点右侧全都是 >= 该元素的区间
int p = partition(arr, l, r);
// 重复在左区间和右区间上重复上述流程
quickSortInternal(arr, l, p - 1);
quickSortInternal(arr, p + 1, r);
}
private static int partition(int[] arr, int l, int r) {
// 随机在当前数组中选一个数
int randomIndex = random.nextInt(l, r);
swap(arr, l, randomIndex);
int v = arr[l];
// arr[l + 1..j] < v
// arr[j + 1..i) >= v
// i表示当前正在扫描的元素
int j = l;
for (int i = l + 1; i <= r; i++) {
if (arr[i] < v) {
swap(arr, j + 1, i);
j++;
}
}
// 将基准值和最后一个 < v的元素交换,基准值就落在了最终位置
swap(arr, l, j);
return j;
}
//交换三连
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
b。双方向クイックロー
//7.2快速排序
public static void quickSort2(int[] arr) {
quickSortInternal2(arr, 0, arr.length - 1);
}
private static void quickSortInternal2(int[] arr, int l, int r) {
if (r - l <= 0) {
return;
}
int p = partition2(arr, l, r);
quickSortInternal2(arr, l, p - 1);
quickSortInternal2(arr, p + 1, r);
}
private static int partition2(int[] arr, int l, int r) {
int randomIndex = random.nextInt(l, r);
swap(arr, l, randomIndex);
int v = arr[l];
// arr[l + 1..i) <= v
// [l + 1..l + 1) = 0
int i = l + 1;
// arr(j..r] >= v
// (r...r] = 0
int j = r;
while (true) {
// i从前向后扫描,碰到第一个 >= v的元素停止
while (i <= j && arr[i] < v) {
i++;
}
// j从后向前扫描,碰到第一个 <= v的元素停止
while (i <= j && arr[j] > v) {
j--;
}
if (i >= j) {
break;
}
swap(arr, i, j);
i++;
j--;
}
// j落在最后一个 <= v的元素身上
swap(arr, l, j);
return j;
}
//交换三连
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
c。スリーウェイクイックロー
//7.3 三路快排
public static void quickSort3(int[] arr) {
quickSortInternal3(arr, 0, arr.length - 1);
}
private static void quickSortInternal3(int[] arr, int l, int r) {
if (r - l <= 0) {
return;
}
int randomIndex = random.nextInt(l, r);
swap(arr, l, randomIndex);
int v = arr[l];
// arr[l + 1..lt] < v
// lt是指向最后一个<v的元素
int lt = l;
// arr[lt + 1..i) == v
// i - 1是最后一个 = v的元素
int i = lt + 1;
// arr[gt..r] > v
// gt是第一个 > v的元素
int gt = r + 1;
// i从前向后扫描和gt重合时,所有元素就处理完毕
while (i < gt) {
if (arr[i] < v) {
// arr[l + 1..lt] < v
// arr[lt + 1..i) == v
swap(arr, i, lt + 1);
i++;
lt++;
} else if (arr[i] > v) {
// 交换到gt - 1
swap(arr, i, gt - 1);
gt--;
// 此处i不++,交换来的gt - 1还没有处理
} else {
// 此时arr[i] = v
i++;
}
}
// lt落在最后一个 < v的索引处
swap(arr, l, lt);
// arr[l..lt - 1] < v
quickSortInternal3(arr, l, lt - 1);
// arr[gt..r] > v
quickSortInternal3(arr, gt, r);
}
//交换三连
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
d。非再帰的なクイックソート
//借助栈来实现非递归分治快排
public static void quickSortNonRecursion(int[] arr) {
Deque<Integer> stack = new ArrayDeque<>();
// 栈中保存当前集合的开始位置和终止位置
int l = 0;
int r = arr.length - 1;
stack.push(r);
stack.push(l);
while (!stack.isEmpty()) {
// 栈不为空时,说明子区间还没有处理完毕
int left = stack.pop();
int right = stack.pop();
if (left >= right) {
// 区间只有一个元素
continue;
}
int p = partition(arr, left, right);
// 依次将右区间的开始和结束位置入栈
stack.push(right);
stack.push(p + 1);
// 再将左侧区间的开始和结束位置入栈
stack.push(p - 1);
stack.push(left);
}
}
private static int partition(int[] arr, int l, int r) {
// 随机在当前数组中选一个数
int randomIndex = random.nextInt(l, r);
swap(arr, l, randomIndex);
int v = arr[l];
// arr[l + 1..j] < v
// arr[j + 1..i) >= v
// i表示当前正在扫描的元素
int j = l;
for (int i = l + 1; i <= r; i++) {
if (arr[i] < v) {
swap(arr, j + 1, i);
j++;
}
}
// 将基准值和最后一个 < v的元素交换,基准值就落在了最终位置
swap(arr, l, j);
return j;
}
//交换三连
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
e。掘削方法
基本的な考え方は Hoareの 方法と同じですが、交換は実行されなくなりますが、割り当ては実行されます(ピットを埋める +ピット を掘る)
//7.5 挖坑法
public static void quickSortDigPit(int[] arr) {
quickSortDigPitInternal(arr, 0, arr.length - 1);
}
private static int quickSortDigPitInternal(int[] array, int left, int right) {
int i = left;
int j = right;
int pivot = array[left];
while (i < j) {
while (i < j && array[j] >= pivot) {
j--;
}
array[i] = array[j];
while (i < j && array[i] <= pivot) {
i++;
}
array[j] = array[i];
}
array[i] = pivot;
return i;
}
4.7つのソートコードのコレクション
「JavaSevenSortingCodeCollection」を参照してください。