冒泡排序:
#include "Bubble_Sort.h"
void bubble_sort01(int array[], int length)
{
for (int i = 1; i < length; i++)
{
for (int j = 1; j < length - i; j++)//大数沉底
{
if (array[j] < array[j - 1])
{
swap(array[j], array[j - 1]);
}
}
}
}
void bubble_sort02(int array[], int length)
{
bool flag = true;
while (flag)//如果有一趟没有发生交换,说明排序已经完成
{
flag = false;
for (int i = 1; i < length; i++)//大数沉底
{
if (array[i] < array[i - 1])
{
swap(array[i], array[i - 1]);
flag = true;//这一趟发生了交换,则为true,否则为false
}
}
}
}
void bubble_sort03(int array[], int length)
{
int pos = length;
int flag;
while (pos > 0)//
{
flag = pos;
pos = 0;
for (int i = 1; i < flag; i++)//大数沉底
{
if (array[i] < array[i - 1])
{
swap(array[i], array[i - 1]);
pos = i;//记录最后做交换的位置i,i之后的数列必定有序(包含i)
}
}
}
}
插入排序:
#include "Insert_Sort.h"
void insert_sort01(int array[], int length)
{
int firstNum;//从无序区开始的第一个值
for (int i = 1; i < length; i++)//保证数组从0至i-1都为有序序列
{
if (array[i] < array[i - 1])//若选定数比之前的有序数列最大值大,不需要做调整
{
firstNum = array[i];
int j = i - 1;
for (; (array[j] > firstNum) && (j >= 0); j--)
{
array[j + 1] = array[j];//将比array[i]大的数向后移位1个位置
}
array[j + 1] = firstNum;//将array[i]插入到有序序列合适的位置
}
}
}
归并排序:
#include "Merge_Sort.h"
const int minUnit = 1;
void mergeData(int array[], int posL, int posR, int* temp)
{
int mid = (posL + posR) / 2;
int l = posL;
int r = mid + 1;
int k = 0;
while (mid >= l&&posR >= r)
{
if (array[l] < array[r])
{
temp[k++] = array[l++];//左右两个序列长度为1时,可确保左右两个序列有序,所以合并序列时可以直接取序列第一个值
}
else
{
temp[k++] = array[r++];//左右两个序列长度为1时,可确保左右两个序列有序,所以合并序列时可以直接取序列第一个值
}
}
while (l > mid&&posR >= r)//当左序列取尽且右序列还有值时,可直接添加右序列剩下的值可确保合并的序列依然有序
{
temp[k++] = array[r++];
}
while (r > posR&&mid >= l)//当右序列取尽且左序列还有值时,可直接添加右序列剩下的值可确保合并的序列依然有序
{
temp[k++] = array[l++];
}
k = 0;
for (int i = posL; i <= posR; i++)
{
array[i] = temp[k++];
}
}
void mergeAction(int array[], int posL, int posR, int* temp)
{
if (posR - posL > minUnit)
{
mergeAction(array, posL, (posL + posR) / 2, temp);//对左面序列进行排序
mergeAction(array, (posL + posR) / 2 + 1, posR, temp);//对右面序列进行排序
}
mergeData(array, posL, posR, temp);//合并左右两个序列
}
void merge_sort01(int array[], int posL, int posR)
{
int * temp = new int[posR - posL + 1]();
mergeAction(array, posL, posR, temp);
delete[] temp;
}
快速排序:
#include "Quick_Sort.h"
int adjustArray01(int array[], int l, int r)
{
int i = l, j = r;
int x = array[i];//基准数的位置,将它设为空缺位
while (i < j)
{
while ((i < j) && (array[j] > x))//从后往前寻找比基准数小的值
{
j--;
}
if (i < j)
{
array[i] = array[j];//将该值赋予之前空缺位的位置,该值原本的位置为新的空缺位位置
i++;
}
while ((i < j) && (array[i] < x))//从前往后寻找比基准数大的值
{
i++;
}
if (i < j)
{
array[j] = array[i];//将该值赋予之前空缺位的位置,该值原本的位置为新的空缺位位置
j--;
}
}//循环结束之后保证基准数之前的值都小于基准数,基准数之后的值都大于基准数
array[i] = x;
return i;//i作为递归的左区最大值和右区最小值
}
void quick_sort01(int array[], int l, int r)
{
if (l < r)
{
int i = adjustArray01(array, l, r);
quick_sort01(array, l, i - 1);//递归调用之后,保证每个基准数(每个数),之前的值都小于基准数,基准数之后的值都大于基准数
quick_sort01(array, i + 1, r);//递归调用之后,保证每个基准数(每个数),之前的值都小于基准数,基准数之后的值都大于基准数
}
}
void quick_sort02(int array[], int l, int r)
{
if (l < r)
{
int i = l, j = r;
int x = array[i];//基准数的位置,将它设为空缺位
while (i < j)
{
while ((i < j) && (array[j] > x))//从后往前寻找比基准数小的值
{
j--;
}
if (i < j)
{
array[i++] = array[j];//将该值赋予之前空缺位的位置,该值原本的位置为新的空缺位位置
}
while ((i < j) && (array[i] < x))//从前往后寻找比基准数大的值
{
i++;
}
if (i < j)
{
array[j--] = array[i];//将该值赋予之前空缺位的位置,该值原本的位置为新的空缺位位置
}
}//循环结束之后保证基准数之前的值都小于基准数,基准数之后的值都大于基准数
array[i] = x;
quick_sort02(array, l, i - 1);//递归调用之后,保证每个基准数(每个数),之前的值都小于基准数,基准数之后的值都大于基准数
quick_sort02(array, i + 1, r);//递归调用之后,保证每个基准数(每个数),之前的值都小于基准数,基准数之后的值都大于基准数
}
}
选择排序:
#include "Select_Sort.h"
void select_sort01(int array[], int length)
{
int minPos;
for (int i = 0; i < length; i++)
{
minPos = i;
for (int j = i; j < length; j++)
{
if (array[minPos] > array[j])
{
minPos = j; //获取无序序列最小值的位置
}
}
swap(array[i], array[minPos]);//交换无序序列最小值和有序序列的最后一个值的位置
}
}
希尔排序:
#include "Shell_Sort.h"
void shell_sort01(int array[], int length)
{
for (int gap = length / 2; gap > 0; gap /= 2)//分解为gap个组
{
for (int i = 0; i < gap; i++)//有多少步长就需要遍历几次
{
for (int j = i + gap; j < length; j += gap)//从此处开始插排,i+gap表示从第二个值开始遍历,符合插排,每个元素相隔gap个位置
{
int k = j - gap;
int temp = array[j];
while (temp < array[k])
{
array[k + gap] = array[k];
k -= gap;
}
array[k + gap] = temp;
}
}
}
}
void shell_sort02(int array[], int length)
{
for (int gap = length / 2; gap > 0; gap /= 2)//分解为gap个组
{
for (int i = gap; i < length; i++)//每次比较所有组,每次比较所有组,可节省一次遍历
{
int k = i - gap;
int temp = array[i];
while (temp < array[k])//从此处开始插排,i+gap表示从第二个值开始遍历,符合插排,每个元素相隔gap个位置
{
array[k + gap] = array[k];
k -= gap;
}
array[k + gap] = temp;
}
}
}