排序相关算法实现
在数据结构与算法学习过程中，为更加深刻理解算法，本文对课程中排序部分算法进行了实现。本文仅提供算法代码参考，相关算法详解请参考青岛大学王卓老师的视频课程：数据结构与算法基础（青岛大学-王卓）
排序相关算法
定义标识符
// 查找
#include <cstdlib>
#include <iostream>
#include <string>
#include <stdio.h>
#include <cstring>
using namespace std;
// 函数结果状态代码
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 // 设记录不超过20个
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define MAX_TREE_SIZE 100
#define MAXQSIZE 100
#define MVNum 100 // 最大顶点数
#define MaxInt 32767 // 表示极大值
//Status 是函数的类型，其值是函数结果状态代码
typedef int Status;
typedef int KeyType; // 设关键字为整型
定义顺序数据表
// 数据结构体
typedef struct {
char name;
int score;
}InfoType;
typedef struct { // 定义每个记录（数据元素）的结构
KeyType key; // 关键字
InfoType otherinfo; // 其他数据项
}RedType;
typedef struct { // 定义顺序表的结构
RedType r[MAXSIZE + 1]; // 存储顺序表的向量
// r[0]一搬做哨兵或缓冲区
int length; // 顺序表的长度
}SqList;
插入排序
// 插入排序
void InsertSort(SqList& L) {
int i, j;
for (i = 2; i <= L.length; i++) {
if(L.r[0].key < L.r[i-1].key){ // 若<，需将L.r[i]插入有序子表
L.r[0] = L.r[i]; // 复制为哨兵
for (j = i - 1; L.r[0].key < L.r[j].key; --j) {
L.r[j + 1] = L.r[j]; // 记录后移
}
L.r[j + 1] = L.r[0]; // 插入到正确位置
}
}
}
折半插入排序
// 折半插入排序
void BInsertSort(SqList& L) {
for(int i=2;i<=L.length;i++){ //依次插入第2~第n个元素
L.r[0] = L.r[i]; // 当前插入元素存到哨兵位置
int low = 1;
int high = i - 1; // 采用二分查找法查找插入位置
while (low <= high) {
int mid = (low + high) / 2;
if (L.r[0].key < L.r[mid].key) {
high = mid - 1; // 在下半区查找
}
else {
low = mid + 1; // 在上半区查找
} // 循环结束，high+1则为插入位置
}
for (int j = i - 1; j >= high + 1; --j) { // 移动元素
L.r[j + 1] = L.r[j]; // 移动元素
}
L.r[high + 1] = L.r[0]; // 插入到正确位置
}
} // BInsertSort
希尔排序
// 希尔排序
/*
仅适用于线性表为顺序表的情况
"dlta" 为增量序列
"dk" 为增量序列中的步长
*/
void ShellInsert(SqList& L, int dk) {
// 对顺序表L进行一趟增量为dk的Shell排序，dk为步长因子
for (int i = dk + 1; i <= L.length; ++i) {
// dk步顺序插入排序
if (L.r[i].key < L.r[i - dk].key) {
L.r[0] = L.r[i];
int j;
for (j = i - dk; j > 0 && (L.r[0].key < L.r[j].key); j = j - dk) {
L.r[j + dk] = L.r[j];
}
L.r[j + dk] = L.r[0];
}
}
}
void ShellSort(SqList& L, int dlta[], int t) {
// 按增量序列dlta[0...t-1]对顺序表L作希尔排序
for (int k = 0; k < t; ++k) {
ShellInsert(L, dlta[k]); // 一趟增量为dlta[k]的插入排序
}
} // ShellSort
冒泡排序
// 冒泡排序
void bubble_sort(SqList &L){ // 冒泡排序算法
int m, i, j;
int flag = 1; // flag作为是否发生交换的标记
RedType x; // 交换时临时存储
for (m = 1; m <= L.length - 1 && flag == 1 ; m++) { // 总共需要m趟
flag = 0;
for (j = 1; j <= L.length - m; j++) {
if(L.r[j].key>L.r[j+1].key){ // 发生逆序
flag = 1; // 发生交换，flag置为1，若本趟没有发生交换，flag保持为0
x = L.r[j];
L.r[j] = L.r[j + 1];
L.r[j + 1] = x; // 交换
}// end if
}// for j
}// for m
}
快速排序
// 快速排序
void QSort(SqList &L,int low,int high){ // 对顺序表L快速排序
if (low < high) { // 长度大于1
int pivotloc = Partition(L, low, high);
// 将L.r[low...high]一分为二，pivotloc为枢轴元素排好序的位置
QSort(L,low, pivotloc - 1); // 对低子表递归排序
QSort(L, pivotloc + 1, high); // 对高子表递归排序
}// end if
}// QSort
int Partition(SqList& L, int low, int high) {
L.r[0] = L.r[low];
KeyType pivotkey = L.r[low].key; // 选择枢轴元素
while (low < high) { // 若长度小于等于1，不执行排序（避免执行L.r[low]=L.r[high]）
while (low < high && L.r[high].key >= pivotkey) {
--high; // 若比枢轴大，high位置往右移
}
L.r[low] = L.r[high]; // 将比枢轴小的元素移到low指向的位置
while (low < high && L.r[low].key <= pivotkey) {
++low; // 若比枢轴小，low位置往左移
}
L.r[high] = L.r[low]; // 将比枢轴大的元素移到high指向的位置
}
L.r[low] = L.r[0]; // 最后low指针指向中间位置时，将0位置的枢轴元素放到low指向的位置
return low;
}// Partition
简单排序
// 简单排序
void SelectSort(SqList& L) {
for (int i = 1; i < L.length; i++) {
int k = i; // 最小值位置初始化
for (int j = i + 1; j <= L.length; j++) {
if (L.r[j].key < L.r[k].key) k = j;// 记录最小值位置
}// for j
if (k != i) swap(L.r[i],L.r[k]); // 交换位置,把最小值放在已排序列后
}// for i
}// SelectSort
堆排序
堆调整
// 堆排序
/*
"len"为R中元素的数量
*/
// 堆调整
void HeadAdjust(SqList &L, int k, int len) {
// 函数"HeadAdjust"将元素k为根的子树进行调整
L.r[0] = L.r[k]; // r[0]暂存子树的根结点
for (int i = 2 * k; i <= len; i *= 2) { // 沿key较大的子结点向下筛选
// 这里是根据二叉树的特殊性质，对顺序表进行二叉树结构的模拟遍历（猜的，待研究）
if (i < len && L.r[i].key < L.r[i + 1].key) {
i++; // 取key较大的子结点的下标
} // if 1
if (L.r[0].key >= L.r[i].key) {
break; // 筛选结束
}// if 2
else {
L.r[k] = L.r[i]; // 将R[i]调整到双亲结点上
k = i; // 修改k值，以便继续向下筛选
}// if 2 end
}// for i 2*k
L.r[k] = L.r[0]; // 被筛选结点的值放入最终位置
}// HeadAdjust
堆排序
void HeadSort(SqList& L) { // 对L.R[1]到L.R[len]进行堆排序
int i;
for (i = L.length / 2; i >= 1; i--) {
HeadAdjust(L, i, L.length); // 建初始堆
}// for i n/2
for(i=L.length;i>1;i--){ // 进行n-1趟排序
swap(L.r[1], L.r[i]); // 根与最后一个元素交换
HeadAdjust(L, 1, i - 1);// 对R[1]到R[i-1]重新建堆
}// for i n
}// HeapSort
测试代码及结果
测试代码：
int main()
{
SqList L;
char names[] = { 'A','B','C','D','E','F','G','H' };
int scores[] = { 77,46,98,56,100,87,57,90 };
L.length = 8;
cout << "数据排序前顺序：" << endl;
for (int i = 1; i <= 8; i++) {
L.r[i].key = scores[i-1];
L.r[i].otherinfo.score = scores[i - 1];
L.r[i].otherinfo.name = names[i - 1];
cout << names[i - 1] << "的分数为：" << scores[i - 1] << endl;
}
SqList HL = L;
HeadSort(HL);
cout << "HeadSort堆排序结果: " << endl;
for (int i = 1; i <= 8; i++) {
cout << HL.r[i].otherinfo.name << "的分数为：" << HL.r[i].otherinfo.score << endl;
}
HL = L;
SelectSort(HL);
cout << "SelectSort简单排序结果: " << endl;
for (int i = 1; i <= 8; i++) {
cout << HL.r[i].otherinfo.name << "的分数为：" << HL.r[i].otherinfo.score << endl;
}
HL = L;
QSort(HL,1,8);
cout << "QSort快速排序结果: " << endl;
for (int i = 1; i <= 8; i++) {
cout << HL.r[i].otherinfo.name << "的分数为：" << HL.r[i].otherinfo.score << endl;
}
HL = L;
bubble_sort(HL);
cout << "bubble_sort冒泡排序结果: " << endl;
for (int i = 1; i <= 8; i++) {
cout << HL.r[i].otherinfo.name << "的分数为：" << HL.r[i].otherinfo.score << endl;
}
HL = L;
int dlta[] = { 1,3,5,7}; // 第一个数据从[1]开始
int t = 2;
ShellSort(HL, dlta,t);
cout << "ShellSort希尔排序结果: " << endl;
for (int i = 1; i <= 8; i++) {
cout << HL.r[i].otherinfo.name << "的分数为：" << HL.r[i].otherinfo.score << endl;
}
HL = L;
BInsertSort(HL);
cout << "BInsertSort折半排序结果: " << endl;
for (int i = 1; i <= 8; i++) {
cout << HL.r[i].otherinfo.name << "的分数为：" << HL.r[i].otherinfo.score << endl;
}
HL = L;
InsertSort(HL);
cout << "InsertSort插入排序结果: " << endl;
for (int i = 1; i <= 8; i++) {
cout << HL.r[i].otherinfo.name << "的分数为：" << HL.r[i].otherinfo.score << endl;
}
system("pause");
return OK;
}
测试结果：
扫一扫
531
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
