ソートを選択
時間/空間の複雑さ：O（n ^ 2）/ O（1）
機能：1つずつ比較し、単純ですが遅い
説明：選択ソートの基本的なアルゴリズムは、選択後にソートする間隔から最小のものを選択し、交換値はa [0]に格納され、残りのソートされていない間隔から最小値が選択されて交換され、a [1]に格納されます。a[1]の数値はa [0]よりも大きいだけです。類推により、ソートを実現できます。
/*******************************************************************************
*****************
* FUNCTION
* sort
*DESCRIPTION
* select sort
*PARAMETERS
* a[] [IN] the sort object
*RETURNS
* void
*****************
*******************************************************************************/
void SelectSort( int a[])
{
int i, j, x;
for (i = 0; i <= 9; i ++)
for (j = i + 1; j <= 10; j ++)
if (a[i] > a[j])
{
x = a[i];
a[i] = a[j];
a[j] = x;
}
return a;
}
バブルソート
時間/空間の複雑さ：O（n ^ 2）平均/ O（1）
機能：2つずつ比較する、単純ですが遅い
説明：バブルソートは、小さな要素を前方に調整するか、大きな要素を後方に移動することです。比較とは、隣接する2つの要素の比較であり、これら2つの要素間でも交換が行われます。n個の数値をバブルソートする場合は、n-1個の比較を実行する必要があります。最初の比較では、nj個のペアワイズ比較が実行され、j番目の比較ではnj個のペアワイズ比較が実行されます。
/*******************************************************************************
*****************
* FUNCTION
* sort
*DESCRIPTION
* bubble sort
*PARAMETERS
* a[] [IN] the sort object
*RETURNS
* void
*****************
*******************************************************************************/
void BubbleSort (int a[])
{
int i, j, x;
for (i = 0; i <= 9; i ++)
for (j = 0; j < 9 - i; j ++)
if (a[j] > a[j + 1])
{
x = a[j];
a[j] = a[j + 1];
a[j + 1] = x;
}
return a;
}
クイックソート
時間/空間の複雑さ：O（n〖log〗_2n）平均/ O（n〖log〗_2n）
特徴：再帰的な分割統治、理解しにくい、高速
説明：データを分割して独立してソートする1回の並べ替え2つの部分では、1つの部分のすべてのデータが他の部分のすべてのデータよりも小さいため、この方法に従って、データの2つの部分をすばやく並べ替えることで、並べ替えプロセス全体を再帰的に実行できます。 、データ全体がシーケンスシーケンスになるようにします。
/*******************************************************************************
*****************
* FUNCTION
* sort
*DESCRIPTION
* quick sort
*PARAMETERS
* a[] [IN] the sort object
* left [IN] the left boundary of a
* right [IN] the right boundary of a
*RETURNS
* void
*****************
*******************************************************************************/
void QuickSort (int a[], int left, int right)
{
int i, j, x;
i = left;
j = right;
x = a[left];
if (left >= right)
{
return a;
}
while(i < j)
{
while(i < j && x <= a[j])
{
j --;
}
a[i] = a[j];
while(i < j && x >= a[i])
{
i ++;
}
a[j] = a[i];
}
a[i] = x;
QuickSort (a, left, i - 1);
QuickSort (a, i + 1, right);
return a;
}
マージソート
時間/空間の複雑さ：O（n〖log〗_2n）/ O（n）
機能：再帰的、最初に分散してからマージ、理解しにくい、高速
説明：（1）n個のレコードをn個の長さとして扱う1.1。
（2）テーブルが隣接している場合は、順序を組み合わせてテーブルを作成しないでください。
（3）長さnの順序付きリストに結合されるまで、手順（2）を繰り返します。
/*******************************************************************************
*****************
* FUNCTION
* sort
*DESCRIPTION
* merge sort
*PARAMETERS
* a[] [IN] the sort object
* L[] [IN] subsequence
* R[] [IN] subsequence
* l [IN] length of L[]
* r [IN] lengtn of R[]
* n [IN] length of a[]
*RETURNS
* void
*****************
*******************************************************************************/
//Two ordered sequences L and R are merged into a,
//r and l are the length of R and L.
void Merge(int a[], int L[], int R[], int l, int r)
{
int i= 0,j = 0,k = 0;
//The elements of the two subsequences are compared inturn,
//and the smaller ones are taken out and put into a.
while(i < l && j < r)
{
if(L[i] <= R[j])
a[k++] = L[i++];
else
a[k++] = R[j++];
}
//Merge the remanining elements on the left into a.
while(i < l)
{
a[k++] = L[i++];
}
//Merge the remaining elements on the right into a.
while(j < r)
{
a[k++] = R[j++];
}
}
//Recursive body
void MergeSort(int a[],int n)
{
if(n > 1)
{
int mid = n / 2;
int i, j;
//Allocate memory to the left and right arrays.
//int *left = (int*)malloc(sizeof(int) * mid);
//int *right = (int*)malloc(sizeof(int) * (n - mid));
int left[mid];
int right[n - mid];
//Assign values to the left and right arrays.
for(i = 0; i < mid; i++)
left[i] = a[i];
for(j = mid; j < n; j++)
right[j] = a[j];
//Recursion continues on the left and right arrays.
MergeSort(left,mid);
MergeSort(right,n - mid);
//Merge two arrays.
Merge(a,left,right,mid,n - mid);
//free(left); //Free memory
//free(right);
}
return a;
}
補間ソート
時間/空間の複雑さ：O（n ^ 2）平均/ O（1）
機能：補間を順番に比較します。単純で、速度はオブジェクトの順序の程度によって異なります
説明：挿入ソートは、ソートされたレコードにレコードを挿入することです。シーケンスシーケンスでは、レコードを挿入した後、シーケンス全体が順番に残ります。挿入ソートのより簡単な方法は、直接挿入ソートです。挿入位置を決定する方法は、挿入されるレコードのキー値を、右から左に順序付けられた領域の各レコードと比較することです。
/*******************************************************************************
*****************
* FUNCTION
* sort
*DESCRIPTION
* interpolation sort
*PARAMETERS
* a[] [IN] the sort object
* n [IN] length of a
* step [IN] interval
*RETURNS
* void
*****************
*******************************************************************************/
//Step size can be spacified for improved version InterpolationSort.
int InterpolationSortPlus(int a[], int n ,int step)
{
int i, j;
for (i = step; i < n; i++)
{
//compare the inserted values step by step forward.
for (j = i; j >= step && a[j] < a[j - step]; j -= step)
{
int x = 0;
x = a[j];
a[j] = a[j - step];
a[j - step] = x;
}
}
return a;
}
ヒルソート
時間/空間の複雑さ：O（n ^ 2）平均/ O（1）
機能：補間ソートに基づいて、オブジェクトの順序の程度に調整が行われます。
説明：ヒルソートは、直接挿入ソートに基づく改良です。つまり、コールドソートシーケンスは一定の増分でいくつかのグループに分割され、等距離のものは同じ2つのグループにあり、次に直接挿入ソートが実行されます。グループ。ここでの固定増分はn / 2から始まり、毎回元の半分に減少します。
/*******************************************************************************
*****************
* FUNCTION
* sort
*DESCRIPTION
* shell sort
*PARAMETERS
* a[] [IN] the sort object
* n [IN] length of a
*RETURNS
* void
*****************
*******************************************************************************/
//Shell sort calls InterpolationSortPlus.
int ShellSort(int a[], int n)
{
int step; //Set a step size.
for (step = n / 2; step >0 ; step /= 2)
{
InterpolationSortPlus(a, n, step);
}
return a;
}
カウントソート
時間/空間の複雑さ：O（n + k）/ O（n + k）
機能：値を比較する必要がなく、単純で、狭い範囲で並べ替えるのが高速です。
説明：1。並べ替える配列内の最大要素と最小要素を見つけます
。2。配列内の値iを持つ各要素の出現回数をカウントし、配列Cのi番目の項目に格納します
。3。すべてのカウントを累積します（Cの最初の要素から開始して、各アイテムが前のアイテムに追加されます）
。4。元の並べ替えられた配列を逆入力します。
/*******************************************************************************
*****************
* FUNCTION
* sort
*DESCRIPTION
* counter sort
*PARAMETERS
* a[] [IN] the sort object
* n [IN] length of a
*RETURNS
* void
*****************
*******************************************************************************/
void CounterSort(int a[], int n)
{
//The maximum and minimum values of the sequence are obtained
//and the differential value d is calculated.
int max, min, i, d;
max = a[0];
min = a[0];
for ( i = 1; i < n; i++)
{
if (a[i] > max)
{
max = a[i];
}
if(a[i] < min)
{
min = a[i];
}
}
d = max - min;
//Create and initializes an array of size d.
int *c = (int*)malloc(sizeof(int) * (d + 1));
for ( i = 0; i < d +1; i ++)
{
c[i] = 0;
}
//count the number of corresponding indexes.
for ( i = 0; i < n; i++)
{
c[a[i] - min] = c[a[i] - min] + 1;
}
//Assign value in turn according to statistical quantities.
for (i =0; i < n; )
for (int j = 0; j < d +1; j ++)
{
if (c[j] > 0)
{
for ( int t = 0; t < c[j]; t ++)
{
a[i] = j + min;
i ++;
}
}
}
free(c);
return a;
}
バケットソート
時間/空間の複雑さ：O（n + k）平均/ O（n + k）
機能：値を比較する必要がなく、より複雑で、より高速なソート。
説明：バケットソートは、カウントソートのアップグレードバージョンです。関数のマッピング関係を利用しており、高効率の秘訣はマッピング関数の決定にあります。バケットソートの動作原理：入力データが均一に分散されていると仮定すると、データは限られた数のバケットに分割され、各バケットは個別にソートされます（他のソートアルゴリズムを使用することも、バケットソートを引き続き使用することもできます。ソートの再帰的方法）。
この記事は複数の本と複数のウェブサイトに言及しており、詳細は利用できなくなりました。気分を害した場合は、連絡して削除してください。