|
|
 #pragma once
  /**//**//**//*
 --- 冒泡排序 ---
自下而上的两两比较，小泡排在大泡前，一趟冒出一个最小泡。
 */
void BubbleSort(int nArray[], int nLength)
 {
int i = nLength - 1;
int j = 0;
int temp = 0;
for (int i = nLength - 1; i > 0; --i)
  {
for (int j = nLength - 2; j >= nLength - i - 1 ; --j)
{
if (nArray[j] > nArray[j + 1])
{
temp = nArray[j + 1];
nArray[j + 1] = nArray[j];
nArray[j] = temp;
 }
}
}
}
/**//**//**//*
--- 选择排序 ---
自下而上的两两比较，记录最小数的下标，将最上面的数与最小数交换。
*/
void SelectSort(int nArray[], int nLength)
{
int tempIndex = 0;
int tempValue = 0;
for (int i = 0; i < nLength; ++i)
{
tempIndex = i;
for (int j = i + 1; j < nLength; ++j)
{
if (nArray[tempIndex] > nArray[j])
{
tempIndex = j;
}
}
tempValue = nArray[i];
nArray[i] = nArray[tempIndex];
nArray[tempIndex] = tempValue;
}
}
/**//**//**//*
--- 插入排序 ---
将数据插入到已排序的序列中，边找合适的位置，边移动数据，找到合适位置插入数据。
*/
void InsertSort(int nArray[], int nLength)
{
for (int i = 1; i < nLength; ++i)
{
int temp = nArray[i];
int j = i;
for (; j > 0 && nArray[j - 1] > temp; --j)
{
nArray[j] = nArray[j - 1];
}
nArray[j] = temp;
}
}
/**//**//**//*
--- 快速排序 ---
是对冒泡排序的改进。
1．先从数列中取出一个数作为基准数;
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边;
3．再对左右区间重复第二步，直到各区间只有一个数.
分区过程可以形象的描述为“挖坑填数”：
1．将基准数nBase挖出形成第一个坑nArray[nLow];
2．nHigh--由后向前找比nBase小的数，找到后挖出此数填前一个坑nArray[nLow]中;
3．nLow++由前向后找比nBase大的数，找到后也挖出此数填到前一个坑nArray[nHigh]中;
4．再重复执行2，3二步，直到nLow==nHigh，将基准数nBase填入nArray[nLow]中.
*/
int AdjustArray(int nArray[], int nLow, int nHigh)
{
int nBase = nArray[nLow];
while(nLow < nHigh)
{
while(nLow < nHigh && nBase <= nArray[nHigh])
--nHigh;
if (nLow < nHigh)
{
nArray[nLow++] = nArray[nHigh];
}
while(nLow < nHigh && nBase > nArray[nLow])
++nLow;
if (nLow < nHigh)
{
nArray[nHigh--] = nArray[nLow];
}
}
nArray[nLow] = nBase;
return nLow;
}
void QuickSort(int nArray[], int nLow, int nHigh)
{
if (nLow < nHigh)
{
int nMid = AdjustArray(nArray, nLow, nHigh);
QuickSort(nArray, 0, nMid - 1);
QuickSort(nArray, nMid + 1, nHigh);
}
}
/**//**//**//*
--- 希尔排序 ---
是对直接插入排序算法的改进，又称缩小增量排序。
1、将数组进行分组，下标相差d的为一组；
2、对每组中全部元素进行排序；
3、然后再用一个较小的增量d, 重复1、2，直到d为1时，排序完成。
一般增量取值为上一次的一半，d = 1/2 d，第一次取值为数组长度的一半。
*/
void ShellSort(int nArray[], int nLength)
{
for (int nDifference = nLength / 2; nDifference > 0; nDifference = nDifference / 2)
{
for (int i = nDifference; i < nLength; ++i)
{
int temp = nArray[i];
int j = i;
for (; j > 0 && nArray[j - 1] > temp; --j)
{
nArray[j] = nArray[j - 1];
}
nArray[j] = temp;
}
}
}
/**//**//**//*
--- 归并排序 ---
是将两个已经排序的序列合并成一个有序序列。
1、待排序序列分为两个子序列;
2、每个子序列重复步骤1，直到每个子序列只有一个元素;
3、按大小顺序合并两个子序列;
4、重复步骤3，直到合并为一个整体有序序列，排序完成。
*/
void Merge(int nArray[], int nLow, int nHigh)
{
int nFirst = nLow;
int nMid = (nLow + nHigh) / 2;
int nSecond = nMid + 1;
int* p = (int*)malloc(sizeof(int) * (nHigh - nLow + 1));
int nIndex = 0;
while(nFirst <= nMid && nSecond <= nHigh)
{
if (nArray[nFirst] > nArray[nSecond])
{
p[nIndex] = nArray[nSecond++];
}
else
{
p[nIndex] = nArray[nFirst++];
}
++nIndex;
}
while (nFirst <= nMid)
{
p[nIndex++] = nArray[nFirst++];
}
while (nSecond <= nHigh)
{
p[nIndex++] = nArray[nSecond++];
}
for (int i = 0; i <= nIndex && nLow <= nHigh;)
{
nArray[nLow++] = p[i++];
}
free(p);
}
void MergeSort(int nArray[], int nLow, int nHigh)
{
if (nLow < nHigh)
{
int nMid = (nLow + nHigh) / 2;
MergeSort(nArray, nLow, nMid);
MergeSort(nArray, nMid+1, nHigh);
Merge(nArray, nLow, nHigh);
}
}
/**//**//**//*
--- 堆排序 ---
1、先将数组转换为完全二叉树；
2、调整二叉树形如大顶堆；
3、将根结点与最后一个叶子结点互换，即将最大元素放在数组的末尾，数组的长度减一；
4、再重复2、3，直到数组长度为1，排序完成。
*/
void AdjustHeap(int nArray[], int nLength, int nIndex)
{
int nLeft = nIndex * 2 + 1;
int nRight = nIndex * 2 + 2;
int nParent = nIndex;
while(nLeft < nLength && nRight < nLength)
{
int nBigIndex = (nArray[nLeft] > nArray[nRight] ? nLeft : nRight);
if (nArray[nParent] < nArray[nBigIndex])
{
int temp = nArray[nParent];
nArray[nParent] = nArray[nBigIndex];
nArray[nBigIndex] = temp;
nLeft = nBigIndex * 2 + 1;
nRight = nBigIndex * 2 + 2;
}
break;
}
}
void BuildHeap(int nArray[], int nLength)
{
for (int i = nLength / 2 - 1; i >= 0; --i)
{
AdjustHeap(nArray, nLength, i);
}
}
void HeapSort(int nArray[], int nLength)
{
BuildHeap(nArray, nLength);
while(nLength > 1)
{
int temp = nArray[0];
nArray[0] = nArray[nLength - 1];
nArray[nLength - 1] = temp;
AdjustHeap(nArray, --nLength, 0);
}
}
void Test_Sort()
{
int nArray[5] = {1,3,2,5,4};
//BubbleSort(nArray, 5);
//SelectSort(nArray, 5);
//InsertSort(nArray, 5);
//QuickSort(nArray, 0, 4);
//ShellSort(nArray, 5);
//MergeSort(nArray, 0, 4);
HeapSort(nArray, 5);
for (int n = 0; n < 5; ++n)
{
std::cout << nArray[n] << " ";
}
std::cout << std::endl;
}
|