安定性、の内部および外部のソートソートのソートはどのようなものです。1.概念のソートをよく理解してください
並べ替え：いわゆる並べ替え、それがラインアップ操作を増加または減少、特定のサイズや特定のキーワードに従った、レコードの束を作ることです。
安定性：それはレコードの配列は、同じキーを持つ複数のレコードをソートすることが想定される並べ替えた場合、これらのレコードの相対的順序は、元の順序で、すなわち不変のままで、R [I] = R [J]前、およびR [i]をR [J]前、および並べ替えの順序で、R [i]は依然としてアルゴリズムをソートする安定であると言われている[J]、Rは、そうでなければ不安定であると知られます。
安定ソートアルゴリズムではないソート、クイックソート、シェルソート、ヒープソートを選択
バブルソート、挿入ソート、ソートするソートアルゴリズムをマージし、基数ソートは安定しています。
内部ソート：ソート・メモリー上のすべてのデータ要素。
外部ソート：データは、メモリ内の非常に多くの要素であることが、内部ソート処理の間で必要に応じてデータをメモリにソートすることができない移動することはできません。
2.お馴染みの挿入、ヒル、選択、排出スタック、バブリングは、基数ソート以下、カウント、マージ：
ソート原則、安定性を達成するためのコード、時間と空間の複雑さ、アプリケーションシナリオを
挿入ソート：直接挿入ソート、単純な挿入ソートで、基本的な考え方は次のとおりです。1つのキーの値によってその大きさに応じてソートするレコードがすでにソートされた順序付けられたシーケンス内に挿入され、すべてのレコードまで完了日を挿入し、新しい順序付けられたシーケンスを取得します。
直接挿入ソート特性が要約されている：
1.要素の近くに順序付けられた集合、高い直接挿入ソート時間効率を
2時間計算：O（N ^ 2）
前記空間複雑：O（1）、安定ソートアルゴリズムであります
4.安定性：
#include <stdio.h>
#include <stdlib.h>
void Printf(int array[],int size)
{
for (int i = 0; i < size; ++i)
{
printf("%d ", array[i]);
}
printf("\n");
}
void Printf(int array[],int size)
{
for (int i = 0; i < size; ++i)
{
printf("%d ", array[i]);
}
printf("\n");
}
void Insert_Sort(int *array, int size)
{
int i, j;
for (i = 1; i < size; ++i) //待排序的
{
for (j = 0; j < i; ++j) //排好序的
{
if (array[i] < array[j])
{
int tmp = array[i]; //需要排序的元素array[i]
array[i] = array[j]; //向后搬移
array[j] = tmp; //填入记录的数据
}
}
}
}
int main()
{
int array[] = { 8,3,2,1,9,5,6,0,4,7 };
int size = sizeof(array)/sizeof(array[0]);
printf("原始数据：\n");
Printf(array, size);
//插入排序
Insert_Sort(array, size);
printf("插入排序后的数据：\n");
Printf(array, size);
system("pause");
return 0;
}
ヒル並び替え：も狭いインクリメンタル方式として知られているシェルソート、。シェルソート単位で記録パケットを押すの主題である、直接挿入ソートの使用は、各ソートアルゴリズムは、増加とともに徐々に減少し、より多くのキーワードをそれぞれ含む、増分に減少したときに、ファイル全体がただ1つのグループに分割され、アルゴリズムは終了します。
ヒルソート機能の概要：
1.ヒルソートは、直接挿入ソート用に最適化されています。
ギャップ> 1を予めソートされている場合2.目的は、規則的アレイに近づくことです。ときにギャップ== 1、配列が近いと秩序となっているので、すぐになります。このよう全体に、最適な結果を達成するために。私たちは、性能比較テストを実現することができます。
3.平均時間複雑由来悪いヒル計算を導出するために必要とされるソートの時間複雑さ、：O（N ^ 1.3-N ^ 2）
4.安定性：不安定
#include <stdio.h>
#include <stdlib.h>
void Printf(int array[],int size)
{
for (int i = 0; i < size; ++i)
{
printf("%d ", array[i]);
}
printf("\n");
}
void Shell_Sort(int *array, int size)
{
int i, j;
int gap;
int tmp;
for (gap = size / 2; gap > 0; gap = gap / 2)
{
for (i = gap; i < size; i++)
{
tmp = array[i];
for (j = i - gap; (j >= 0) && (array[j] > tmp); j = j - gap)
{
array[j + gap] = array[j];
}
array[j + gap] = tmp;
}
}
}
int main()
{
int array[] = { 8,3,2,1,9,5,6,0,4,7 };
int size = sizeof(array)/sizeof(array[0]);
printf("原始数据：\n");
Printf(array, size);
//希尔排序
Shell_Sort(array, size);
printf("希尔排序后的数据：\n");
Printf(array, size);
system("pause");
return 0;
}
選択ソート：すべてのデータ要素を排出ソートするまで、各データ要素は、シーケンスの開始位置に格納された要素のソート最小（または最大）から選択されます。
：直接の選択は、ソート概要特長
1.ダイレクト選択ソートと思いますが、非常によく理解されているが、効率はほとんど使用されません実際には、非常に良いではありません。
2時間計算：O（N ^ 2）
前記空間複雑：O（1）
4.安定性：不安定
#include <stdio.h>
#include <stdlib.h>
void Printf(int array[],int size)
{
for (int i = 0; i < size; ++i)
{
printf("%d ", array[i]);
}
printf("\n");
}
void Printf(int array[],int size)
{
for (int i = 0; i < size; ++i)
{
printf("%d ", array[i]);
}
printf("\n");
}
void Select_Sort(int *array, int size)
{
int i, j, k, tmp;
for (i = 0; i < size; ++i)
{
for (j = i + 1; j < size; ++j)
{
//k = i;
if (array[j] < array[i])
{
//k = j;
tmp = array[j];
array[j] = array[i];
array[i] = tmp;
}
}
}
}
int main()
{
int array[] = { 8,3,2,1,9,5,6,0,4,7 };
int size = sizeof(array)/sizeof(array[0]);
printf("原始数据：\n");
Printf(array, size);
//选择排序
Select_Sort(array, size);
printf("选择排序后的数据：\n");
Printf(array, size);
system("pause");
return 0;
}
ヒープソート：ヒープソート（ヒープソート）は、バルク（バルク）を使用してツリーのソートアルゴリズムを指すソートを選択することでこのようなデータ構造を設計しました。これは、データスタックを選択することで行われます。小さなヒープを構築するために行を降順、杭の列を昇順に内蔵されることに留意されたいです。
#include <stdio.h>
#include <stdlib.h>
void Printf(int array[],int size)
{
for (int i = 0; i < size; ++i)
{
printf("%d ", array[i]);
}
printf("\n");
}
void Swap(int *a, int *b)
{
int t = 0;
t = *a;
*a = *b;
*b = t;
}
void AdjustDown(int *array, int i, int size)
{
int child = i * 2 + 1;
int tmp;
for (tmp = array[i]; 2 * i + 1 < size; i = child) {
child = 2 * i + 1; //注意数组下标是从0开始的，所以左孩子的求发不是2*i
if (child != size - 1 && array[child + 1] > array[child])
++child; //找到最大的儿子节点
if (tmp < array[child])
array[i] = array[child];
else
break;
}
array[i] = tmp;
}
void Heap_Sort(int *array, int size)
{
int i;
for (i = (size - 2) / 2; i >= 0; i--)
{
AdjustDown(array, i, size);
}
for (i = size - 1; i > 0; --i)
{
Swap(&array[0], &array[i]);
AdjustDown(array, 0, i);
}
}
int main()
{
int array[] = { 8,3,2,1,9,5,6,0,4,7 };
int size = sizeof(array)/sizeof(array[0]);
printf("原始数据：\n");
Printf(array, size);
//堆排序
Heap_Sort(array, size);
printf("堆排序后的数据：\n");
Printf(array, size);
system("pause");
return 0;
}
バブルソート：彼らは交換順序（例えば、降順、AからZまでの最初の文字のような）エラーが引き継いだ場合、それは繰り返し、隣接する二つの要素を比較するために、ソートする列の要素を訪問しました。隣接する要素を交換する必要がないまで働い訪問要素が繰り返され、その要素の列が完成ソートされていると言うことです。
要約の特徴的なバブルソート：
1.バブルソートに理解することは非常に簡単である発注
2時間計算：O（N ^ 2）
前記空間複雑：O（1）
4.安定性：
#include <stdio.h>
#include <stdlib.h>
void Printf(int array[],int size)
{
for (int i = 0; i < size; ++i)
{
printf("%d ", array[i]);
}
printf("\n");
}
void Printf(int array[],int size)
{
for (int i = 0; i < size; ++i)
{
printf("%d ", array[i]);
}
printf("\n");
}
//冒泡排序（升序）
void Bubble_Sort(int *array, int size)
{
int i = 0;
int j = 0;
for (int i = 0; i < size - 1; ++i)
{
for (j = 0; j < size - i - 1; ++j)
{
if (array[j] > array[j + 1])
{
int tmp = array[j];
array[j] = array[j + 1];
array[j + 1] = tmp;
}
}
}
}
int main()
{
int array[] = { 8,3,2,1,9,5,6,0,4,7 };
int size = sizeof(array)/sizeof(array[0]);
printf("原始数据：\n");
Printf(array, size);
//冒泡排序
Bubble_Sort(array, size);
printf("冒泡排序后的数据：\n");
Printf(array, size);
system("pause");
return 0;
}
マージソート：ソートマージ（MERGE-SORT）でマージソートアルゴリズムの効率的な動作に基づいている非常に一般的なアプリケーションでは、分割を使用して（分割統治）征服します。すなわち、各第1順序付けられたシーケンス、次いでセグメント間の配列を作るために命じ、組み合わせ配列は、完全配列を注文し、注文されました。2は、ソートされたリスト順序付きリストにマージされた場合は、ウェイ・マージと呼ばれます。
：ソートまとめていますマージ
欠点は思考の並べ替えをマージし、1 O（N）スペースの複雑さをマージする必要が外側のディスクにスケジューリング問題を解決するために多くのですが。
2.時間の複雑さ：O（N * logN個）
前記空間複雑：O（N）
4.安定性：
#include <stdio.h>
#include <stdlib.h>
#define N 10
void Printf(int array[],int size)
{
for (int i = 0; i < size; ++i)
{
printf("%d ", array[i]);
}
printf("\n");
}
void merge(int arr[], int low, int mid, int high)
{
int i, k;
int *tmp = (int *)malloc((high - low + 1) * sizeof(int));
int left_low = low;
int left_high = mid;
int right_low = mid + 1;
int right_high = high;
for (k = 0; left_low <= left_high && right_low <= right_high; k++)
{
if (arr[left_low] <= arr[right_low])
{
tmp[k] = arr[left_low++];
}
else
{
tmp[k] = arr[right_low++];
}
}
if (left_low <= left_high)
{
for (i = left_low; i <= left_high; i++)
tmp[k++] = arr[i];
}
if (right_low <= right_high)
{
for (i = right_low; i <= right_high; i++)
tmp[k++] = arr[i];
}
for (i = 0; i < high - low + 1; i++)
arr[low + i] = tmp[i];
free(tmp);
return;
}
void Merge_Sort(int arr[], unsigned int first, unsigned int last)
{
int mid = 0;
if (first < last)
{
mid = (first + last) / 2; /* 注意防止溢出 */
/*mid = first/2 + last/2;*/
//mid = (first & last) + ((first ^ last) >> 1);
Merge_Sort(arr, first, mid);
Merge_Sort(arr, mid + 1, last);
merge(arr, first, mid, last);
}
return;
}
int main()
{
int array[] = { 8,3,2,1,9,5,6,0,4,7 };
int size = sizeof(array)/sizeof(array[0]);
printf("原始数据：\n");
Printf(array, size);
//归并排序
Merge_Sort(array, 0, size - 1);
printf("归并排序后的数据：\n");
Printf(array, size);
system("pause");
return 0;
}
计数排序：计数排序的基本思想是对于给定的输入序列中的每一个元素x，确定该序列中值小于x的元素的个数（此处并非比较各元素的大小，而是通过对元素值的计数和计数值的累加来确定）。一旦有了这个信息，就可以将x直接存放到最终的输出序列的正确位置上。
如果用快速排序，该算法的复杂度为O(nlog^2n)。改用计数排序后，复杂度降为O(nlogn)
计数排序算法是一个稳定的排序算法
#include <stdio.h>
#include <stdlib.h>
void Printf(int array[],int size)
{
for (int i = 0; i < size; ++i)
{
printf("%d ", array[i]);
}
printf("\n");
}
void Count_Sort(int *array, int size)
{
int max = array[0];
int min = array[0];
for (int i = 0; i < size; i++)
{
if (array[i] > max)
max = array[i];
if (array[i] < min)
min = array[i];
}
int range = max - min + 1;
int *b = (int *)calloc(range, sizeof(int));
for (int i = 0; i < size; i++)
{
b[array[i] - min] += 1;
}
int j = 0;
for (int i = 0; i < range; i++)
{
while (b[i]--)
{
array[j++] = i + min;
}
}
free(b);
b = NULL;
}
int main()
{
int array[] = { 8,3,2,1,9,5,6,0,4,7 };
int size = sizeof(array)/sizeof(array[0]);
printf("原始数据：\n");
Printf(array, size);
Count_Sort(array, size);
printf("计数排序后的数据：\n");
Printf(array, size);
system("pause");
return 0;
}
基数排序：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
时间效率 [1] ：设待排序列为n个记录，d个关键码，关键码的取值范围为radix，则进行链式基数排序的时间复杂度为O(d(n+radix))，其中，一趟分配时间复杂度为O(n)，一趟收集时间复杂度为O(radix)，共进行d趟分配和收集。 空间效率：需要2*radix个指向队列的辅助空间，以及用于静态链表的n个指针。
#include <stdio.h>
#include <stdlib.h>
#define RADIX_10 10
#define KEYNUM_31 10
void Printf(int array[],int size)
{
for (int i = 0; i < size; ++i)
{
printf("%d ", array[i]);
}
printf("\n");
}
//基数排序（升序）
int GetNumInPos(int num, int pos)
{
int temp = 1;
for (int i = 0; i < pos - 1; i++)
temp *= 10;
return (num / temp) % 10;
}
void Radix_Sort(int *array, int size)
{
int *array1[RADIX_10];
for (int i = 0; i < 10; i++)
{
array1[i] = (int *)malloc(sizeof(int) * (size + 1));
array1[i][0] = 0;
}
for (int pos = 1; pos <= KEYNUM_31; pos++)
{
for (int i = 0; i < size; i++)
{
int num = GetNumInPos(array[i], pos);
int index = ++array1[num][0];
array1[num][index] = array[i];
}
for (int i = 0, j = 0; i < RADIX_10; i++)
{
for (int k = 1; k <= array1[i][0]; k++)
array[j++] = array1[i][k];
array1[i][0] = 0;
}
}
}
int main()
{
int array[] = { 8,3,2,1,9,5,6,0,4,7 };
int size = sizeof(array)/sizeof(array[0]);
printf("原始数据：\n");
Printf(array, size);
//基数排序
Radix_Sort(array, size);
printf("基数排序后的数据：\n");
Printf(array, size);
system("pause");
return 0;
}