基本排序算法的总结

 

 

#include<iostream>

using namespace std;
#define N 10000
void Print(int a[], const int len);//输出函数
void Sort1(int a[], const int len);//方法一:冒泡
void Sort2(int a[], const int len);//方法二:异或(只能整型)
void Sort3(int a[], const int len);//方法三:插入排序
void Sort4(int a[], const int len);//方法四:选择排序
void Sort5(int a[], const int len);//方法五:希尔排序
void Sort6(int a[], int begin, int end);//方法六：快速排序
void Sort7(int a[], const int len);//方法七：堆排序
void Sort8(int a[], const int len);//方法八：归并排序

 

int main()
{
int a[N],  len, NUM;
cout << "请输入你要使用的排序方:\n1:冒泡排序\n2:异或排序\n3:插入排序\n4:选择排序\n5:希尔排序\n6:快速排序\n7:堆排序\n8:归并排序" << endl;
cin >> NUM;
cout << "请输入排序个数:" << endl;
while (cin >> len)//多组输入
{
cout << "请输入这" << len << "个数:" << endl;
for (int i = 0; i < len; i++)
cin >> a[i];
if (NUM == 1)
if (NUM == 2)Sort2(a, len);
if (NUM == 3)Sort3(a, len);
if (NUM == 4)Sort4(a, len);
if (NUM == 5)Sort5(a, len);
if (NUM == 6)Sort6(a, 0, len - 1);
if (NUM == 7)Sort7(a, len);
if (NUM == 8)Sort8(a, len);
Print(a, len);
cout << "想继续排序吗?想输入Y/y，不想输入N/n:" << endl;
char Y;
cin >> Y;
if (Y == 'N' || Y == 'n')
break;
cout << "请输入你要使用的排序方:\n1:冒泡排序\n2:异或排序\n3:插入排序\n4:选择排序\n5:希尔排序\n6:快速排序\n7:堆排序\n8:归并排序" << endl;
cin >> NUM;
cout << "请输入这" << len << "个数:" << endl;
}
return 0;
}
 

void  Print(int a[], const int len)
{
cout << "用此方法排序后:" << endl;
for (int i = 0; i < len; i++)
{
if (i == 0)
cout << a[i];
else
cout << " " << a[i];
}
cout << "\n" << endl;
}



void Sort1(int a[], const int len)//方法一:冒泡
{
for (int i = 0; i < len - 1; i++)
{
for (int j = 0; j < len - i - 1; j++)
{
if (a[j] > a[j + 1])//每次把体格最大数沉底
{
int t = a[j];
a[j] = a[j + 1];
a[j + 1] = t;
}
}
}
}

//冒泡排序图的形象化，图片来自维基




void Sort2(int a[], const int len)//方法二:异或，缺点:只能整型
{
for (int i = 0; i < len - 1; i++)
{
for (int j = 0; j < len - i - 1; j++)
{
if (a[j] > a[j + 1])//其实和冒泡差不多
{
a[j] ^= a[j + 1];
a[j + 1] ^= a[j];
a[j] ^= a[j + 1];
}
}
}
}






void Sort3(int a[], const int len)//方法三:插入排序
{
for (int i = 1; i < len; i++)//从第二个开始
{
for (int j = 0; j < i; j++)//从第一个到i-1
{
if (a[j] > a[i])
{
int t = a[i];//先保存最后一个数
for (int k = i; k>j; k--)
{
a[k] = a[k - 1];//从k-1依次向后移动
}
a[j] = t;//保存的值放到j；
break;//插入之后退出
}
}
}

}

 

//插入排序图的形象化，图片来自维基





void Sort4(int a[], const int len)//方法四:选择排序
{
for (int i = 0; i < len - 1; i++)//选择最小的出来
{
int k = i;
for (int j = i + 1; j < len; j++)
{
if (a[j] < a[k])
{
k = j;//保存当前最小的位置
}
}
int t = a[i];
a[i] = a[k];
a[k] = t;
}
}






void Sort5(int a[], const int len)//方法五:希尔排序
{
//先分n组，组内排序，排序之后再分n/2组，排序。n/4...n/8......1
int d = len / 2;//分成d组
//a[0] a[0+d] a[0+2d] a[0+3d]
//a[1] a[1+d] a[1+2d] a[1+3d]
//...
while (d != 0)
{
for (int i = 0; i < d; i++)//排序d组
{
//第i组 a[i+0] a[i+d] a[i+2d] a[i+3d]
for (int j = i; j < len; j += d)//里面组内可以用其他排序
{                             //这里一选择排序为例子
int k = j;
for (int m = j + d; m < len; m += d)
{
if (a[m] < a[k])//找最小元素
{
k = m;
}
}
int t = a[j];//交换
a[j] = a[k];
a[k] = t;
}
}
d /= 2;
}
}






void Sort6(int a[], int belenin, int end)//方法六：快速排序
{
int Part(int a[], int belenin, int end);//声明排序函数
//数组分为两部分，放左右两边，分别对两部分进行排序
//然后两部分里面再分为两个子部分，依此类推，像递归一样
if (belenin >= end)
return;//不需要排序
int k = Part(a, belenin, end);
Sort6(a, belenin, k - 1);
Sort6(a, k + 1, end);
}


int Part(int a[], int belenin, int end)//方法六的一个调用排序函数
{
int k = belenin;//选择开头
//a[belenin]放到a[i]和 a[j]之间
//左边是i，右边是j
//从左往右 找一个比a[belenin]小的数字
//从右往左 找一个比a[belenin]大的数字
int i = belenin, j = end;
while (i < j)//当i==j的时候 i就是a[belenin]应该在的位置
{
while (i < j&&a[j] >= a[belenin])j--; //a[j]右边数字都要大于等于a[belenin]
while (i < j&&a[i] <= a[belenin])i++;//a[i]右边数字都要小于等于a[belenin]
int t = a[i];//交换a[i]和a[j]
a[i] = a[j];
a[j] = t;
}
//交换a[belenin]和a[i]
int t = a[belenin];
a[belenin] = a[i];
a[i] = t;
return i;

}

 

//快速排序图的形象化，图片来自维基

/*


堆的结构类似于完全二叉树，每个结点的值都小于或者等于其左右孩子结点的值，或者每个节点的值都大于或等于其左右孩子的值


堆排序过程将待排序的序列构造成一个堆，选出堆中最大的移走，再把剩余的元素调整成堆，找出最大的再移走，重复直至有序


来看一下实现*/


//堆排序
void Sort7(int a[], const int len)
{
int i;
void Heapify(int a[], const int first, int end);//声明排序函数
//初始化堆，从最后一个父节点开始
for (i = len / 2 - 1; i >= 0; --i){
Heapify(a, i, len);
}
//从堆中的取出最大的元素再调整堆
for (i = len - 1; i > 0; --i){
int temp = a[i];
a[i] = a[0];
a[0] = temp;
//调整成堆
Heapify(a, 0, i);
}
}
//再看 调整成堆的函数


void Heapify(int a[], const int first, int end)//声明方法七中的一部分
{
int father = first;
int son = father * 2 + 1;
while (son < end){
if (son + 1 < end && a[son] < a[son + 1]) ++son;
//如果父节点大于子节点则表示调整完毕
if (a[father] > a[son]) break;
else {
//不然就交换父节点和子节点的元素
int temp = a[father];
a[father] = a[son];
a[son] = temp;
//父和子节点变成下一个要比较的位置
father = son;
son = 2 * father + 1;
}
}

}

 

//堆排序图的形象化，图片来自维基



void Sort8(int a[], const int len)
{
void Merlene(int a[], int relen[], int start, int end);//声明方法八的一部分
//创建一个同样长度的序列,用于临时存放
int reg[len];
Merlene(a, reg, 0, len - 1);
}


void Merlene(int a[], int relen[], int start, int end)
{
if (start >= end)return;
int len = end - start, mid = (len >> 1) + start;


//分成两部分
int start1 = start, end1 = mid;
int start2 = mid + 1, end2 = end;
//然后合并
Merlene(a, relen, start1, end1);
Merlene(a, relen, start2, end2);




int k = start;
//两个序列一一比较,哪的序列的元素小就放进relen序列里面,然后位置+1再与另一个序列原来位置的元素比较
//如此反复,可以把两个有序的序列合并成一个有序的序列
while (start1 <= end1 && start2 <= end2)
relen[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];


//然后这里是分情况,如果a2序列的已经全部都放进relen序列了然后跳出了循环
//那就表示a序列还有更大的元素(一个或多个)没有放进relen序列,所以这一步就是接着放
while (start1 <= end1)
relen[k++] = a[start1++];


//这一步和上面一样
while (start2 <= end2)
relen[k++] = a[start2++];
//把已经有序的relen序列放回a序列中
for (k = start; k <= end; k++)
a[k] = relen[k];

}

//归并排序图的形象化，图片来自维基