1. 折半查找和二叉排序树的构造与查找
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
#define SearchError -1
using KeyType = int; //关键字类型
//线性表的元素类型
typedef struct
{
KeyType key; //每个元素的关键字
int other; //每个元素的其他信息
} TEleType;
//顺序表
typedef struct
{
TEleType *R;
int length;
} SSTable;
//折半查找
pair<int, int> BinarySearch(SSTable ST, int size, KeyType key)
{
int l = 0, r = size - 1;
int count = 0;
while (l <= r)
{
count ++ ;
int mid = l + r >> 1;
if (key > ST.R[mid].key) l = mid + 1;
else if (key < ST.R[mid].key) r = mid - 1;
else return {mid, count}; //查找成功，返回元素在有序数组中的位置和查找次数
}
return {SearchError, count}; //查找失败，返回出错标志和查找次数
}
typedef struct
{
KeyType key;
int index; //记录该元素在数组中的下标
} ElemType;
typedef struct BSTNode
{
ElemType data; //二叉链表的数据域
BSTNode *lChild, *rChild; //左、右指针域
} BSTNode, *BSTree;
//二叉排序树的插入
void InsertBST(BSTree& T, ElemType arr_data)
{
//若当前树为空，那么就给当前树创建一个根节点
if (!T)
{
BSTNode *node = new BSTNode;
node->data.key = arr_data.key;
node->data.index = arr_data.index;
node->lChild = node->rChild = nullptr;
T = node;
}
//若不为空，则判断应该插入当前树的左子树还是右子树
else if (arr_data.key < T->data.key) InsertBST(T->lChild, arr_data);
else if (arr_data.key > T->data.key)InsertBST(T->rChild, arr_data);
}
//将数组构造成二叉排序树
void CreateBSTree(BSTree &T, vector<KeyType> arr)
{
T = nullptr;
for (int i = 0; i < arr.size(); i++)
{
InsertBST(T, {arr[i], i}); //把数组的当前元素的值和下标都传入InsertBST函数
}
}
//二叉排序树的查找，查找元素在有序数组中的位置，返回元素位置和查找次数
pair<int, int> BSTSearch(BSTree &T, KeyType key, int searchCount)
{
searchCount ++ ;
if (!T) return {SearchError, searchCount}; //当前树的根节点为空，已经查找到树的末尾，代表查找失败，返回出错标志和查找次数
if (key < T->data.key) return BSTSearch(T->lChild, key, searchCount); //key比当前树的根节点小就去当前树的左子树找
else if (key > T->data.key) return BSTSearch(T->rChild, key, searchCount); //key比当前树的根节点大就去当前树的右子树找
else return {T->data.index, searchCount}; //若key等于当前树的根节点的值，查找成功，返回元素在有序数组中的位置和查找次数
}
bool cmp(TEleType x1, TEleType x2)
{
return x1.key < x2.key;
}
int main()
{
int size;
cout << "请输入数组大小：";
cin >> size;
vector<KeyType> arr(size);
cout << "请输入数组的值："; //45 12 53 3 37 100 24 61 55 90 78
for (int i = 0; i < size; i ++ ) cin >> arr[i];
//折半查找
cout << endl << "折半查找：" << endl;
SSTable SST;
SST.R = new TEleType[size];
SST.length = size;
for (int i = 0 ; i < SST.length; i ++ ) SST.R[i].key = arr[i];
sort(SST.R, SST.R + size, cmp); //使用折半查找的数组必须有序
cout << "排序后为：";
for (int i = 0; i < SST.length; i++) cout << SST.R[i].key << " ";
cout << endl;
for (int i = 0; i < 2; i++)
{
cout << "请输入你想要查找的值：";
int key;
cin >> key;
pair<int, int> res = BinarySearch(SST, size, key);
if (res.first == SearchError) cout << "查找了" << res.second << "次，没有找到该元素" << endl;
else cout << "查找了" << res.second << "次，在数组中的位置为：" << res.first << endl;
}
//二叉排序树的查找
cout << endl << "二叉排序树：" << endl;
BSTree T;
CreateBSTree(T, arr);
cout << "已将数组转化成二叉排序树！" << endl;
//在二叉排序树上查找元素在有序数组中的位置，返回元素位置和查找次数
for (int i = 0; i < 2; i++)
{
cout << "请输入你想要在二叉排序树上查找的值：";
int key;
cin >> key;
int searchCount = 0;
pair<KeyType, int> res = BSTSearch(T, key, searchCount);
if (res.first == SearchError) cout << "查找了" << res.second << "次，没有找到该值" << endl;
else cout << "查找了" << res.second << "次，在二叉排序树种找到该值，在数组arr中下标为：" << res.first << endl;
}
return 0;
}
结果：
2. 九大排序算法
（1）直接插入排序
void DInsertSort(SqList &L)
{
for (int i = 2; i <= L.length; ++ i)
{
L.R[0].key = L.R[i].key;
int j = i - 1;
for (; L.R[0].key < L.R[j].key; -- j)
{
L.R[j + 1].key = L.R[j].key;
}
L.R[j + 1].key = L.R[0].key;
}
}
（2）折半插入排序
//在直接插入排序中，是将当前数插入到前面已经排好序的序列中
//而寻找当前数插在已经排好序的序列的位置，可以使用折半查找找到这一位置
int BinarySearch(SqList &L, int r)
{
KeyType key = L.R[r + 1].key;
int l = 1;
while (l <= r)
{
int mid = l + r >> 1;
if (key > L.R[mid].key) l = mid + 1; //key值更大插入点在右区间
else r = mid - 1; //key值更小或相等插入点在左区间
}
return r + 1; // 返回插入点的后一位置
}
void BInsertSort(SqList &L)
{
for (int i = 2; i <= L.length; ++ i)
{
L.R[0].key = L.R[i].key;
int j = BinarySearch(L, i - 1); //找到该L.R[i],key的插入点
//将[j, i-1]的记录整体后移至[j+1, i]的位置
for (int k = i; k >= j + 1; -- k) L.R[k].key = L.R[k - 1].key;
L.R[j].key = L.R[0].key;
}
}
（3）希尔排序
void ShellInsert(SqList &L)
{
//设每次排序的增量dk = 5, 2, 1
int dArr[] = {5, 2, 1};
int dSize = sizeof(dArr) / sizeof(int);
for (int dk : dArr)
{
for (int i = dk + 1; i <= L.length; ++ i)
{
L.R[0].key = L.R[i].key;
int j = i - dk;
for ( ; j > 0 && L.R[0].key < L.R[j].key; j -= dk)
{
L.R[j + dk].key = L.R[j].key;
}
L.R[j + dk].key = L.R[0].key;
}
}
}
（4）冒泡排序
void swap(KeyType &x1, KeyType&x2)
{
KeyType tmp = x1;
x1 = x2;
x2 = tmp;
}
void BubbleSort(SqList &L)
{
int flag = 1; //记录上一趟是否进行了交换。若上一趟进行了交换，排序继续。否则代表排序已完毕，退出循环
for (int i = 1; flag && i <= L.length - 1 ; ++ i)
{
flag = 0;
for (int j = 1; j <= L.length - i; ++ j)
{
if (L.R[j].key > L.R[j + 1].key)
{
swap(L.R[j].key, L.R[j + 1].key);
flag = 1;
}
}
}
}
（5）快速排序
int Partition(SqList &L, int l, int r)
{
L.R[0].key = L.R[l].key; //将第一个值作为枢轴值放入下标为0的位置
while (l < r)
{
//下标为l的位置没有存放元素，从后面找个比枢轴值小的搬到前面
while (l < r && L.R[r].key >= L.R[0].key) -- r;
L.R[l].key = L.R[r].key;
//下标为r的位置没有存放元素，从后面找个比枢轴值大的搬到后面
while (l < r && L.R[l].key <= L.R[0].key) ++ l;
L.R[r].key = L.R[l].key;
}
L.R[l].key = L.R[0].key; //把枢轴值放到l和r重合的位置
return l;
}
void QuickSort(SqList &L, int l, int r)
{
if (l >= r) return;
int pivot = Partition(L, l, r); //将当前区间内的元素进行分区，找到枢轴值的下标
QuickSort(L, l, pivot - 1), QuickSort(L, pivot + 1, r); //递归枢轴的左右区间，将左右区间都进行分区
}
（6）选择排序
void SelectSort(SqList &L)
{
//每趟选择一个最小的依次放在前面
for (int i = 1; i <= L.length - 1; ++ i )
{
int k = i; //k为最小值的下标
for (int j = i + 1; j <= L.length; ++ j)
{
if (L.R[j].key < L.R[k].key)
{
k = j;
}
}
if (k != i) swap(L.R[i].key, L.R[k].key);
}
}
（7）堆排序
//调整堆 --> 使每个结点中，以该结点为根节点的树是大根堆
void AdjustHeap(SqList &L, int s, int m)
{
//s代表该节点要插入的位置，初始时该结点的位置就是在还未调整的完全二叉树的位置
KeyType x = L.R[s].key; //保存该结点的值
for (int j = 2 * s; j <= m; j *= 2)//j代表该结点的左孩子下标
{
if (j < m && L.R[j + 1].key > L.R[j].key) ++ j; //找出左右孩子中值较大的
if (x >= L.R[j].key) break; //结点的值比左右孩子都大，不需要调整，结点就保留在当前位置上
//两个孩子有一个比该结点的值小
L.R[s].key = L.R[j].key; //值大的孩子换到当前树根节点的位置
s = j; //该结点要插入的位置变成值大的孩子的下标
}
L.R[s].key = x; //找到插入点后，将该结点插入
}
//建初堆 --> 建大根堆
void CreateHeap(SqList &L)
{
//将顺序表中所有结点依次编号，转变成完全二叉树的形式
//从最后一个非叶子节点开始依次调整以该结点为根节点的堆，调整成大根堆
int n = L.length;
for (int i = n / 2; i >= 1; -- i)
{
AdjustHeap(L, i, n);
}
}
void HeapSort(SqList &L)
{
CreateHeap(L); //建初堆
for (int i = L.length; i > 1; -- i)
{
//表中第一个元素就是堆顶，就是当前堆的最大值，将每次调整堆后得到的堆顶换到表尾，每次向前推进一格
swap(L.R[1].key, L.R[i].key);
AdjustHeap(L, 1, i - 1);
}
}
（8）归并排序
void MergeSort(SqList &L, int l, int r)
{
//递归出口
if (l >= r) return;
//确定分界点
int mid = l + r >> 1;
//递归左右区间
MergeSort(L, l, mid), MergeSort(L, mid + 1, r);
//合并
vector<KeyType> tmp(r - l + 2); //准备一个临时数组，存放左右区间合并后的新区间
int i = l, j = mid + 1, k = 1;
while (i <= mid && j <= r)
{
if (L.R[i].key < L.R[j].key) tmp[k ++ ] = L.R[i ++ ].key;
else tmp[k ++ ] = L.R[j ++ ].key;
}
//哪边区间有剩余，直接接到tmp后面
while (i <= mid) tmp[k ++ ] = L.R[i ++ ].key;
while (j <= r) tmp[k ++ ] = L.R[j ++ ].key;
//tmp复制回L中
for (int i = 1, j = l; j <= r; ++ i, ++ j) L.R[j].key = tmp[i];
}
（9）基数排序
//采用静态链表实现，例：将10个三位数按从小到大排好
#define KeyNum 3 //三位数，三个关键字：个十百
typedef struct
{
int next; //next存储下一元素下标
KeyType key; //keys数组存储关键字的个十百位
} SLNode; //静态链表的结点类型
typedef struct
{
SLNode *R; //数组存储所有数字转化成SLNode类型的结点
int len; //静态链表长度
} SList; //静态链表类型
#define EveryKeyMax 9 //个十百三个关键字的最大值
typedef int ArrType[EveryKeyMax + 1]; //准备10个桶拿来分配
//将静态链表中的所有元素分配到桶中
KeyType ord(SList &sl, int p, int k)
{
switch (k)
{
case 0: //依据个位映射
return sl.R[p].key % 10;
case 1: //十位
return sl.R[p].key / 10 % 10;
case 2: //百位
return sl.R[p].key / 100;
}
}
void Distribute(SList &sl, ArrType &st, ArrType &ed, int k) //k代表第几次分配，即依据哪个关键字分配
{
//对十个桶初始化
for (int i = 0; i <= EveryKeyMax; ++ i) st[i] = 0;
//分配
for (int p = sl.R[0].next; p; p = sl.R[p].next)
{
int j = ord(sl, p, k); //得到该元素的映射值，例：k == 0，得到该元素的个位
if (!st[j]) st[j] = p; //若st数组的第j个位置此时为空，将该元素映射到这个位置上
else sl.R[ed[j]].next = p; //若不为空，则代表已经链接了一个个位相同的结点，将当前结点插入到后面
ed[j] = p;
}
}
//从十个桶中收集
void Collect(SList &sl, ArrType &st, ArrType &ed)
{
//找到第一个关键字非空的链表
int i;
for (i = 0; i <= EveryKeyMax && !st[i]; ++ i);
sl.R[0].next = st[i]; //更新新链表的第一个元素下标
int t = ed[i]; //t存新链表的最后一个元素的下标
//找到剩下几个非空的进行链接
for (int p = i + 1; p <= EveryKeyMax; ++ p)
{
if (st[p])
{
sl.R[t].next = st[p];
t = ed[p];
}
}
sl.R[t].next = 0; //将最后一个元素的next指针置为0
}
void RadixSort(SqList &L)
{
//将数组转化为静态链表
SList sl;
sl.len = L.length;
sl.R = new SLNode[sl.len + 1];
//初始状态下静态链表第0个位置的next指针指向第1个位置的元素，即存储第1个元素的下标
sl.R[0].next = 1;
for (int i = 1; i <= L.length; ++ i)
{
sl.R[i].key = L.R[i].key;
if (i != L.length) sl.R[i].next = i + 1;
else sl.R[i].next = 0; //将最后一个结点的next值设为0
}
ArrType st, ed; //例：st[0]记录第一个以0为个位的数的下标，ed[0]记录最后一个以0为个位的数的下标
//***三位数 --> 三次分配，三次收集
for (int i = 0; i < KeyNum; ++ i)
{
Distribute(sl, st, ed, i);
Collect(sl, st, ed);
}
//将静态链表复制回数组中
for (int p = sl.R[0].next, i = 1; p; p = sl.R[p].next, ++ i) L.R[i].key = sl.R[p].key;
}
main函数
void MyPrint(ElemType x)
{
cout << x.key << " ";
}
int main()
{
SqList L;
L.length = MAXSIZE;
srand((unsigned)time(0));
for (int i = 1; i <= 9; ++ i)
{
//每次生成十个不重复的随机数
for (int j = 1; j <= MAXSIZE; ++ j)
{
KeyType x;
if (i == 9) x = rand() % 900 + 100; //基数排序三位数，随机数范围[100, 999]
else x = rand() % 10 + 1;
L.R[j].key = x;
for (int k = j - 1; k >= 1; -- k)
{
if (L.R[k].key == L.R[j].key)
{
-- j;
break;
}
}
}
cout << "初始数组：";
for (int i = 1; i <= L.length; ++ i) cout << L.R[i].key << " ";
cout << endl;
switch (i)
{
case 1:
cout << "直接插入排序后：";
DInsertSort(L);
break;
case 2:
cout << "折半插入排序后：";
BInsertSort(L);
break;
case 3:
cout << "希尔排序后：";
ShellInsert(L);
break;
case 4 :
cout << "冒泡排序后：";
BubbleSort(L);
break;
case 5:
{
cout << "快速排序后：";
int l = 1, r = L.length;
QuickSort(L, l, r);
break;
}
case 6:
cout << "简单选择排序后：";
SelectSort(L);
break;
case 7:
cout << "堆排序后：";
HeapSort(L);
break;
case 8:
{
cout << "归并排序后：";
int l = 1, r = L.length;
MergeSort(L, l, r);
break;
}
case 9:
{
cout << "基数排序后：";
RadixSort(L);
break;
}
}
for_each(L.R + 1, L.R + L.length + 1, MyPrint);
cout << endl << endl;
}
return 0;
}
结果：
3948
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
