目录
【id:205】【20分】B. A DS选择排序_最小绝对差
【id:123】【20分】A. 快速排序
时间限制1s
内存限制128MB
题目描述
给出一个数据序列，使用快速排序算法进行从小到大的排序
输入
第一行输入t，表示有t个测试示例
第二行输入n，表示第一个示例有n个数据
第三行输入n个数据，都是正整数，数据之间用空格隔开
以此类推
输出
每组测试数据，输出每趟快排的结果，即每次排好一个数字结果（长度为1的子序列，不用排，不用输出）。不同测试数据间用空行分隔。
#include <iostream>
using namespace std;
int n;//全局变量n
int partition(int arr[], int low, int high);//函数声明
// 快速排序函数
void quickSort(int arr[], int low, int high) {
if (low < high) {
// 获取分区的索引
int pivotIndex = partition(arr, low, high);
// 输出每趟排序结果
for (int i = 0; i < n; i++) {
if (i == n - 1) {
cout << arr[i];
}
else {
cout << arr[i] << " ";
}
}
cout << endl;
// 递归调用快速排序
quickSort(arr, low, pivotIndex - 1);
quickSort(arr, pivotIndex + 1, high);
}
}
// 分区函数
int partition(int arr[], int low, int high) {
int pivot = arr[low]; // 选择第一个元素作为基准
int i = low+1; //基准后一个元素的索引
for (int j = low+1; j <= high; j++) {
// 如果当前元素小于基准
if (arr[j] < pivot) {
swap(arr[i], arr[j]); // 交换
i++; // 增加小于基准的元素索引
}
}
// 将基准元素放到正确位置，再换回来
swap(arr[low], arr[i-1]);
return i - 1; // 返回基准元素的索引
}
int main() {
int t; cin >> t;
while (t--) {
cin >> n;
int* arr = new int[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
// 调用快速排序
quickSort(arr, 0, n - 1);
if(t!=0)
cout << endl;
}
return 0;
}【id:205】【20分】B. A DS选择排序_最小绝对差
时间限制1s
内存限制128MB
题目描述
给你一个整数数组arr，其中每个元素都不相同。
请你找到所有具有最小绝对差的元素对，并按升序的顺序输出。
最小绝对差，指的是两个元素的差值的绝对值在整个数组中是最小的。
例如，对于数组[4,2,1,3]，元素对[4,2]的绝对差2大于[2,1]的绝对差1。
如果算法涉及到排序，请使用选择排序。
输入
第一行输入t，表示有t个测试样例。
第二行起，每一行首先输入n，表示arr的数组长度，接着输入n个整数。
以此类推，共输入t个测试样例。
输出
每一行按升序输出所有具有最小绝对差的元素对，每个元素对之间用空格隔开。
共输出t行。
注意输出末尾的空格。
#include <iostream>
using namespace std;
int main() {
int t; cin >> t;
while (t--) {
int n;
cin >> n;
int* arr = new int[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int set = 0;//选择排序开始的下标
while (set!=n-1) {//选择排序
int k = set;
for (int i = k; i < n; i++) {//找最小的
if (arr[i] < arr[k]) {
k = i;
}
}
swap(arr[set], arr[k]);
set++;
}
int min = 1000000;
for (int i = 0; i < n-1; i++) {//找到最小的差值
if (arr[i+1] - arr[i] < min) {
min = abs(arr[i] - arr[i + 1]);
}
}
for (int i = 0; i < n - 1; i++) {
if (arr[i+1] - arr[i] == min) {
cout << "[" << arr[i] << "," << arr[i + 1] << "] ";
}
}
if(t!=0)
cout << endl;
}
return 0;
}【id:124】【20分】C. DS内排—堆排序
时间限制1s
内存限制128MB
题目描述
给定一组数据，使用堆排序完成数据的降序排序。（建小顶堆)。
输入
数据个数n，n个整数数据
输出
初始创建的小顶堆序列
每趟交换、筛选后的数据序列，输出格式见样例
#include<iostream>
using namespace std;
void Reset(int arr[],int begin,int end) {
int key = arr[begin];
for (int i = begin * 2; i <= end; i *= 2) {//寻找左右子树
if (i<end && arr[i] > arr[i+1]) {//找左右子树更小的那个,且不越界
i++;
}
if (key <= arr[i]) {//如果满足小项堆
break;
}
arr[begin] = arr[i];//否则交换
begin = i;
}
arr[begin] = key;
}
void Reset1(int arr[], int begin, int end) {
int key = arr[begin];
for (int i = begin * 2; i <= end; i *= 2) {//寻找左右子树
if (i<end && arr[i] < arr[i + 1]) {//找左右子树更小的那个,且不越界
i++;
}
if (key >= arr[i]) {//如果满足小项堆
break;
}
arr[begin] = arr[i];//否则交换
begin = i;
}
arr[begin] = key;
}
int main()
{
int n;
cin >> n;
int* arr = new int[n+1];
arr[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
for (int i = n / 2; i >= 1; i--) {
Reset(arr, i, n);
}
cout << n << " ";
for (int j = 1; j <= n; j++) {
if (j != n)
cout << arr[j] << " ";
else
cout << arr[j];
}
cout << endl;
int end1 = n;
for (int i = 1; i < n; i++) {
swap(arr[1], arr[end1]);
end1--;
for (int i = end1 / 2; i >= 1; i--) {
Reset(arr, i, end1);
}
cout << n << " ";
for (int j = 1; j <= n; j++) {
if (j != n)
cout << arr[j] << " ";
else
cout << arr[j];
}
if(i!=n-1)
cout << endl;
}
return 0;
}【id:129】【20分】D. 2路归并排序
时间限制1s
内存限制128MB
题目描述
给定一组正整数序列，执行2路归并排序算法得到由小到大的序列。要求按2路归并排序树，自下而上自左向右的次序，输出每个有序的子序列。
自顶向下进行，即递归调用 MergeSort(left, mid)、MergeSort(mid, right)
本题约定数组区间为[1, n]， mid = (left + right) / 2，递归子区间为 [left, mid]、[mid + 1, right]
输入
第1行该序列的正整数个数n
第2行n个正整数，元素之间由空格分开
输出
m: 表示2路归并排序树的结点个数
m行，每行是有序的子序列
#include <iostream>
#include <stack>
#include <queue>
using namespace std;
const int maxn = 1e4 + 10;
int dp[maxn];
int emerge[maxn];
int n;
struct nod
{
int s, e;//s是起始点，e是终点
nod* left, * right;//left是左子节点，right是右子节点
nod()
{
left = NULL;
right = NULL;
}
nod(int a, int b)
{
s = a;
e = b;
left = NULL;
right = NULL;
}
};
stack<nod*>ss;
void insert(nod*& root, int left, int right)//这里插入用到了递归
{
if (left >= right)//这个意思是如果节点是独自一个的，也要插入生成节点
{
if (root == NULL)
{
root = new nod(left, right);
}
return;
}
if (root == NULL)//如果这个节点为空就生成一个新节点，起始点就是left，终点就是right
root = new nod(left, right);
int mid = (left + right) / 2;//折半
insert(root->left, left, mid);//左子树就左半边
insert(root->right, mid + 1, right);//右子树就右半边
}
nod* build()
{
nod* root;//n是总共有多少个元素
root = new nod(1, n);//建立根节点，根节点在最顶所以就是最开始的1到n
int mid = (1 + n) / 2;//mid就是折半嘛
insert(root->left, 1, mid);//然后左半边
insert(root->right, mid + 1, n);//右半边
return root;
}
queue<nod*>p;
int height;
void cengxu(nod* root)
{
if (root == NULL)
return;
ss.push(root);//ss是我建立的堆
p.push(root);//p是我建立的队列，层序遍历需要用到队列嘛
while (!p.empty())//如果队列非空就进入循环
{
nod* q = p.front();//取出一个节点
p.pop();
if (q->right != NULL)//然后本题思路是先右节点，所以就如果存在就放入队列里面，并且放入堆里面
{
p.push(q->right);
ss.push(q->right);
height++;//height是我用来统计总共有几个节点的，有就+1，然后我的height初始值为1，所以上面建立根就没+1了
}
if (q->left != NULL)//然后就是左子节点，一样的操作
{
p.push(q->left);
ss.push(q->left);
height++;
}
}
}
void out(int l, int r)
{
for (int i = l; i <= r; i++)//从左边界到有边界输出
{
if (i == r) {
cout << dp[i];
}else
cout << dp[i] << " ";
}
cout << endl;
}
void emerge_sort(nod* root)
{
if (root == NULL)
return;
int left = root->s, right = root->e;//获取这个节点的起点和终点
int mid = (left + right) / 2;//折半
int i, j, k;
for (i = k = left, j = mid + 1; j <= right && i <= mid;)//这部分就是排序算法了
{ //空数组emerge[]，和原顺序数组dp[]，
if (dp[i] <= dp[j]) //实现思路我举个例子原数组六个树1，6，5，2，3，4，然后对半分开
emerge[k++] = dp[i++];//left指向1，right指向4，mid+1指向2，分成1，5，6 | 2，3，4
else //1<2,emerge:1 5>2,emerge:1,2 5>3,emerge:1,2,3 5>4,emerge:1,2,3,4
emerge[k++] = dp[j++]; //然后就退出这个循环了
}
while (i <= mid) //前面部分还没放完，但是第二部分放完了，那就把前面部分都放在后面部分
{ //emerge:1，2，3，4，5，6
emerge[k++] = dp[i++];
}
while (j <= right) //这个意思也一样，但是我举得例子里面他已经放完了就不
{
emerge[k++] = dp[j++];
}
for (int m = left; m <= right; m++)//然后我们将emerge的数组放进dp里面，覆盖掉之前没排序的
{
dp[m] = emerge[m];
}
out(left, right);//然后这里我们就输出一下这个节点
}
int main()
{
while (1)
{
cin >> n;
for (int i = 1; i <= n; i++)
{
cin >> dp[i];
}
height = 1;
nod* root = build();
cengxu(root);
cout << height << endl;
while (!ss.empty())
{
emerge_sort(ss.top());
ss.pop();
}
break;
}
}【id:142】【20分】E. 基数排序（内部排序）
时间限制1s
内存限制128MB
题目描述
给定一组数据，对其进行基数升序排序。
输入
测试次数t
每组测试数据一行：数字个数n，后跟n个数字（整数）
注：如果序列中有负数，则每个数字加上最小负数的绝对值，使序列中的数均大于等于0。排序后再减去最小负数的绝对值。
输出
对每组测试数据，输出每趟分配、收集的结果。若分配中该位没有数字，输出NULL。具体输出格式见样例。每组测试数据间以空行分隔。
如果序列中有负数，最后输出减去最小负数绝对值的序列值。
#include <iostream>
#include <queue>
using namespace std;
typedef struct ListNode{
int data;
struct ListNode *next;
} ListNode;
int Get(int k, int a)
{
int temp = 1;
for(int i=0; i<k; i++)
temp *= 10;
a %= temp;
temp /= 10;
a /= temp;
return a;
}
void RadixSort(int v, int n, int *a)
{
int i;
ListNode *p;
for(int k=0; k<v; k++)
{
queue<ListNode *> b[10];
for(i=0; i<n; i++)
{
int num = Get(k+1, a[i]);
p = new ListNode;
p->data = a[i];
p->next = NULL;
b[num].push(p);
}
queue<ListNode *> c;
for(i=0; i<10; i++)
{
cout<<i<<':';
if(b[i].empty())
cout<<"NULL"<<endl;
else
{
while(!b[i].empty())
{
p = b[i].front();
c.push(p);
cout<<"->"<<p->data;
b[i].pop();
}
cout<<"->^"<<endl;
}
}
int len = c.size();
for(i=0; i<len; i++)
{
p = c.front();
c.pop();
a[i] = p->data;
if(i!=len-1)
cout<<p->data<<' ';
else
cout<<p->data<<endl;
}
}
}
int main(void)
{
int t;
cin>>t;
while(t--)
{
int i, n;
cin>>n;
int a[n];
for(i=0; i<n; i++)
cin>>a[i];
int abs = 0;
int max = 0;
for(i=0; i<n; i++)
{
if(a[i]<abs)
abs = a[i];
if(a[i]>max)
max = a[i];
}
for(i=0; i<n; i++)
a[i] += -abs;
max += -abs;
int v = 0;
while(max)
{
max /= 10;
v++;
}
RadixSort(v, n, a);
cout<<endl;
}
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
