[アルゴリズム学習]常用ソートアルゴリズム実装
1.ソートの挿入
ソートを挿入するのは最も簡単で最も直感的なソートアルゴリズムで、その根拠は:N番目の要素に遍歴する時前のN-1の要素はすでにソートして、それでは前のN-1の要素を探してこのN番目の要素を適当な位置に置いて、このようにしてシーケンスの要素を遍歴するまで行きます.アルゴリズムの複雑さも簡単であり,1番目のソートには1の複雑さが必要であり,2番目のソートには2の複雑さが必要であるため,全体の複雑さは1+2+3+......+N=O(N^2)の複雑さである.
/*
*
*/
void InsertSort(int *arr,int n)
{
int j=0,temp;
for(int i=1;i<n;i++)
{
int j=i;
temp=arr[i];
while(j>0)
{
if(temp<arr[j-1])//arr[i]<arr[i-1]， arr[i-1]
{
arr[j]=arr[j-1];
j--;
}else
break;
}
arr[j]=temp;//
print(arr,n);
}
}2、shell並べ替え
shellソートは挿入ソートの改装であり、ソートするたびにシーケンスの要素をある増分によっていくつかのサブシーケンスに分け、これらのサブシーケンスを挿入ソートし、増分が1になるまで各サブシーケンスの要素数を縮小し続け、増分が1になるまでサブシーケンスは元の配列待ちシーケンスと同じになり、この場合は少量の比較と移動だけでシーケンスのソートを完了することができる.
/*
*shell
*/
void ShellSort(int *arr,int n)
{
int incre=n/3+1;
bool tag=true;
do
{
if(incre==1)
tag=false;
ShellSortWithIncre(arr,n,incre);
incre=incre/3+1;
}while(incre>=1&&tag);
}
/*
,
*/
void ShellSortWithIncre(int *arr,int n,int incre)
{
for(int i=incre;i<n;i++)
{
int j=i;
int temp=arr[i];
while(j-incre>=0)
{
if(temp<arr[j-incre])
{
arr[j]=arr[j-incre];
j-=incre;
}else
break;
}
arr[j]=temp;
}
}3、泡立ち順
バブルソートアルゴリズムの考え方:簡単で、シーケンスを巡るたびに最大(小さい)の要素を一番前に置いて、残りのシーケンスに対して親の前のプロセスから、ループが終わるたびにソートされるシーケンスに1つの要素が少なくなり、ソートされるシーケンスが1つの要素に減少するとソートが終了します.したがって,複雑度は最悪の場合O(N^2)である.
/*
*
*/
void BubbleSort(int *arr,int n)
{
bool exchanged=true;
for(int i=0;i<n;i++)
{
exchanged=false;
for(int j=0;j<n-i-1;j++)
{
if(arr[j]>arr[j+1])
{
std::swap(arr[j],arr[j+1]);
exchanged=true;
}
}
if(!exchanged)
return;
}
}4、クイックソート
高速ソートのアルゴリズム思想:1つのピボット要素を選択し、ソートシーケンスを分割し、分割後のシーケンスの1つの部分はピボット要素より小さく、1つの部分はピボット要素より大きく、この2つの分割されたサブシーケンスに対して上述の過程を行う.
/*
*/
void QuickSort(int *arr,int start,int end)
{
int low=start,high=end-1;
int pivot;
if(low<high)
{
pivot=Partition(arr,low,high);
//print(arr,end-start+1);
QuickSort(arr,low,pivot);
QuickSort(arr,pivot+1,end);
}
}
/*
pivot , pivot, pivot
*/
int Partition(int *arr,int start,int end)
{
int pivot=getMediumNum(arr,start,end);
std::swap(arr[start],arr[pivot]);
int pivotNum=arr[start];
//std::cout<<"pivot is "<<pivotNum<<std::endl;
while(start<end)
{
while(start<end&&pivotNum<arr[end])
--end;
if(start<end)
arr[start++]=arr[end];
while(start<end&&arr[start]<=pivotNum)
++start;
if(start<end)
arr[end--]=arr[start];
}
arr[start]=pivotNum;
return start;
}
/*
, ,
*/
int getMediumNum(int *arr,int start,int end)
{
int medium=(start+end)/2;
if(arr[start]<arr[medium])
{
if(arr[medium]<arr[end])
return medium;
else
if(arr[start]>arr[end])
return start;
else
return end;
}else
{
if(arr[medium]>arr[end])
return medium;
else
if(arr[start]>arr[end])
return end;
else
return start;
}
}別の分割方法:
int Partition(int *arr,int start,int end)
{
int x = arr[end];
int i = start - 1;
for(int j=start;j<end;j++)
{
if(arr[j]<=x)
{
++i;
swap(arr[i],arr[j]);
}
}
swap(arr[i+1],arr[end]);
return i+1;
}5、ソートの選択
最小の数を選択するたびに、その数に対応する位置を入れます.
/*
*/
void SelectSort(int *arr,int n)
{
for(int i=0;i<n;i++)
{
int min=i;
for(int j=i;j<n;j++)
{
if(arr[j]<arr[min])
min=j;
}
if(min!=i)
std::swap(arr[i],arr[min]);
}
}6、スタックの順序付け
ヒープの定義:
n個のキーワードシーケンスKl,K 2,...,Knをスタックと呼び、このシーケンスが以下の性質(スタック特性と略称する)を満たす場合にのみ、
(1)ki≦K 2 i及びki≦K 2 i＋1又は(2)Ki≧K 2 i及びki≧K 2 i＋1(1≦i≦)
このシーケンスに格納されたベクトルR[1・・・n]を完全二叉木の格納構造と見なすと、スタックは実質的に以下の性質を満たす完全二叉木である.ツリーのいずれかの非葉接点のキーワードは、その左右の子供(存在する場合)接点のキーワードよりも大きくない(または小さくない).
スタックのこの性質は、1つのシーケンスの中で最も小さい(大きい)要素を迅速に位置決めすることができる.
スタックソートアルゴリズムのプロセスは、1)現在のシーケンスの最小(大)の要素を得る
(2)この要素と最後の要素を交換すると,現在の最小(大)の要素がシーケンスの最後に置かれ,元の最後の要素がシーケンスの一番前に置かれる.
(3)の交換はスタックシーケンスの性質を損なう可能性がある(この場合のシーケンスは最後尾に置かれた元素を除くことに注意する)ため、シーケンスを上スタックの性質を満たすように調整する必要がある.シーケンスの調整が完了するまで、上記の手順を繰り返します.
/*
*
*/
void HeapSort(int *arr,int n)
{
BuildMaxHeap(arr,n);
//std::cout<<" :";
//print(arr,n);
for(int i=n-1;i>0;i--)
{
std::swap(arr[i],arr[0]);
HeapAdjust(arr,0,i);
}
}
/*
*/
void BuildMaxHeap(int *arr,int n)
{
for(int i=n/2-1;i>=0;i--)
{
HeapAdjust(arr,i,n);
}
}
/*
*
*/
void HeapAdjust(int *arr,int start,int n)
{
int rightChild=(start+1)*2;
while(rightChild<n)//
{
if(arr[rightChild]<arr[rightChild-1])
--rightChild;
if(arr[start]<arr[rightChild])
{
std::swap(arr[start],arr[rightChild]);
start=rightChild;
rightChild=(start+1)*2;
}else
break;
}
if(rightChild==n)// ,
{
if(arr[start]<arr[rightChild-1])
std::swap(arr[start],arr[rightChild-1]);
}
}7、集計ソート
並べ替えソートのアルゴリズム思想:並べ替えられるシーケンスを同じ大きさの2つの部分に分けて、この2つの部分を順番に並べ替えて並べ替えて、終わったら順番に合併します
/*
*/
void MergeSort(int *arr,int n)
{
for(int i=1;i<n;i*=2)
{
MergePass(arr,i,n);
std::cout<<i<<" :"<<std::endl;
print(arr,n);
}
}
/*
:
*/
void Merge(int *arr,int start,int mid,int end)
{
int length=end-start;
int i=start,j=mid,p=0;
int *arr2=new int[length];
while(i<mid&&j<end)
{
if(arr[i]<arr[j])
{
arr2[p++]=arr[i];
++i;
}else
{
arr2[p++]=arr[j];
++j;
}
}
while(i<mid)
arr2[p++]=arr[i++];
while(j<end)
arr2[p++]=arr[j++];
p=0;
for(i=start;i<end;i++,p++)
{
arr[i]=arr2[p];
}
delete[] arr2;
}
/*
,
*/
void MergePass(int *arr,int interval,int n)
{
int i=0;
for(;i+2*interval<n;i+=2*interval)
{
Merge(arr,i,i+interval,i+2*interval);
}
if(i+interval<n)
Merge(arr,i,i+interval,n);
}
/*
*/
void MergeSortDC(int *arr,int start,int end)
{
int low=start,high=end;
int mid;
if(low<high-1)
{
mid=(low+high)/2;
MergeSortDC(arr,start,mid);
MergeSortDC(arr,mid,end);
Merge(arr,start,mid,end);
}
}8、基数ソート
//
void RadixSort(int *arr,int n)
{
bool isContinue=true;
vector<int> ivec[10];
int remainder=0,baseNum=1,p=0;
while(isContinue)
{
isContinue=false;
for(int i=0;i<n;i++)
{
remainder=(arr[i]/baseNum)%10;
if(remainder)
isContinue=true;
ivec[remainder].push_back(arr[i]);
}
p=0;
for(int i=0;i<10;i++)
{
int size=ivec[i].size();
for(int j=0;j<size;j++)
{
arr[p++]=ivec[i][j];
}
ivec[i].clear();
}
baseNum*=10;
}
}