直接插入排序
折半排序
希尔排序
冒泡排序
快速排序
堆排序
问题 A: DS排序--直接插入排序
时间限制: 1 Sec 内存限制: 128 MB
提交: 148 解决: 79
[提交][状态][讨论版]
题目描述
给出一个数据序列，使用直接插入排序算法进行降序排序。
输入
第一行输入t，表示有t个测试示例
第二行输入n，表示第一个示例有n个数据(n>1)
第三行输入n个数据，都是正整数，数据之间用空格隔开
以此类推
输出
对每组测试数据，输出每趟排序结果。不同组测试数据间用空行分隔。
样例输入
2
5
111 22 6 444 333
6
21 25 49 25 16 8
样例输出
111 22 6 444 333
111 22 6 444 333
444 111 22 6 333
444 333 111 22 6
25 21 49 25 16 8
49 25 21 25 16 8
49 25 25 21 16 8
49 25 25 21 16 8
49 25 25 21 16 8
问题 B: DS排序--折半插入排序
时间限制: 1 Sec 内存限制: 128 MB
提交: 97 解决: 80
[提交][状态][讨论版]
题目描述
给出一个数据序列，使用折半插入排序算法进行降序排序。
输入
第一行输入t，表示有t个测试示例
第二行输入n，表示第一个示例有n个数据(n>1)
第三行输入n个数据，都是正整数，数据之间用空格隔开
以此类推
输出
对每组测试数据，输出每趟排序结果。不同组测试数据间用空行分隔。
样例输入
2
5
111 22 6 444 333
8
30 13 70 85 39 42 6 20
样例输出
111 22 6 444 333
111 22 6 444 333
444 111 22 6 333
444 333 111 22 6
30 13 70 85 39 42 6 20
70 30 13 85 39 42 6 20
85 70 30 13 39 42 6 20
85 70 39 30 13 42 6 20
85 70 42 39 30 13 6 20
85 70 42 39 30 13 6 20
85 70 42 39 30 20 13 6
问题 C: DS排序--希尔排序
时间限制: 1 Sec 内存限制: 128 MB
提交: 264 解决: 162
[提交][状态][讨论版]
题目描述
给出一个数据序列，使用希尔排序算法进行降序排序。
间隔gap使用序列长度循环除2直到1
输入
第一行输入t，表示有t个测试示例
第二行输入n，表示第一个示例有n个数据(n>1)
第三行输入n个数据，都是正整数，数据之间用空格隔开
以此类推
输出
对每组测试数据，输出每趟排序结果。不同组测试数据间用空行分隔。
样例输入
2
6
111 22 6 444 333 55
8
77 555 33 1 444 77 666 2222
样例输出
444 333 55 111 22 6
444 333 111 55 22 6
444 555 666 2222 77 77 33 1
666 2222 444 555 77 77 33 1
2222 666 555 444 77 77 33 1
问题 D: DS排序--冒泡排序
时间限制: 1 Sec 内存限制: 128 MB
提交: 196 解决: 157
[提交][状态][讨论版]
题目描述
给定一个包含从0到n-1各一次的数组，若使用冒泡排序将其排为升序，问其中需要进行多少次交换
输入
测试数据有多组，
每组由两行组成：第一行包含正整数n（n <= 5000）; 下一行包含从0到n-1的n个整数的序列。
输出
对于每组测试数据，
输出交换次数
样例输入
10
1 3 6 9 0 8 5 7 4 2
样例输出
22
提示
需要考虑有多轮数据输入的情况！也就是第一个cin或者scanf需要用while来进行循环，例如 while(cin>>...)
问题 E: DS排序--快速排序
时间限制: 1 Sec 内存限制: 128 MB
提交: 189 解决: 148
[提交][状态][讨论版]
题目描述
给出一个数据序列，使用快速排序算法进行从小到大的排序
排序方式：以区间第一个数字为枢轴记录
输出方式：每一步区间排序，都输出整个数组
--程序要求--
若使用C++只能include一个头文件iostream；若使用C语言只能include一个头文件stdio
程序中若include多过一个头文件，不看代码，作0分处理
不允许使用第三方对象或函数实现本题的要求
输入
第一行输入t，表示有t个测试示例
第二行输入n，表示第一个示例有n个数据
第三行输入n个数据，都是正整数，数据之间用空格隔开
以此类推
输出
每组测试数据，输出每趟快排的结果，即每次排好一个数字结果（长度为1的子序列，不用排，不用输出）。不同测试数据间用空行分隔。
样例输入
2
6
111 22 6 444 333 55
8
77 555 33 1 444 77 666 2222
样例输出
55 22 6 111 333 444
6 22 55 111 333 444
6 22 55 111 333 444
6 22 55 111 333 444
1 33 77 555 444 77 666 2222
1 33 77 555 444 77 666 2222
1 33 77 77 444 555 666 2222
1 33 77 77 444 555 666 2222
1 33 77 77 444 555 666 2222
问题 B: DS内排—堆排序
时间限制: 1 Sec 内存限制: 128 MB
提交: 224 解决: 159
[提交][状态][讨论版]
题目描述
给定一组数据，使用堆排序完成数据的降序排序。（建小顶堆)。
输入
数据个数n，n个整数数据
输出
初始创建的小顶堆序列
每趟交换、筛选后的数据序列，输出格式见样例
样例输入
8 34 23 677 2 1 453 3 7
样例输出
8 1 2 3 7 23 453 677 34
8 2 7 3 34 23 453 677 1
8 3 7 453 34 23 677 2 1
8 7 23 453 34 677 3 2 1
8 23 34 453 677 7 3 2 1
8 34 677 453 23 7 3 2 1
8 453 677 34 23 7 3 2 1
8 677 453 34 23 7 3 2 1
#include<iostream>
#include<vector>
using namespace std;
void display(int a[], int n)
{
for (int i = 0; i < n; i++)
{
cout << a[i] << " ";
}
cout << endl;
}
void display_from1(int* array, int len)
{
cout << len << " ";
for (int i = 1; i <= len; i++)
{
cout << array[i] << " ";
}
cout << endl;
}
void display_from1_vector(vector<int>H, int len)
{
len = H.size() - 1;
cout << len << " ";
for (int i = 1; i <= len; i++)
{
cout << H[i] << " ";
}
cout << endl;
}
void InSertSort(int a[], int length)
{
int i, j;
for (i = 2; i < length; i++)
{
a[0] = a[i];//将a[0]作为哨兵，存放待插入的元素
for (j = i - 1; a[j] < a[0]; j--)
{
a[j + 1] = a[j];//记录后移
}
a[j + 1] = a[0];//插入到正确位置
display(a, length);
}
}
void binaryInsertSort(int L[], int n) {
int i, j, low, high;
for (i = 2; i < n; ++i)
{
L[0] = L[i];
low = 1; high = i - 1;
while (low <= high)
{
int mid = (low + high) / 2;
if (L[0] > L[mid]) high = mid - 1;
else low = mid + 1;
}
for (j = i - 1; j >= high + 1; --j)
{
L[j + 1] = L[j];
}
L[high + 1] = L[0];
display(L, n);
}
}
void ShellInsert(int* array, int gap, int len) {
int k, i, j, temp;
for (k = 0; k < gap; k++) {
for (i = k; i < len; i += gap) {
temp = array[i];
for (j = i; j > k; j -= gap) {
if (temp > array[j - gap])
array[j] = array[j - gap];
else
break;
}
array[j] = temp;
}
}
}
void ShellSort(int* array, int len) {
int gap = len / 2;
while (true)
{
ShellInsert(array, gap, len);
display(array, len);
if (gap == 1)
break;
gap /= 2;
}
}
void bubble_sort(int* array, int len)
{
int m, i, j, flag = 1, temp, count = 0;
for (m = 0; m < len - 1 && flag == 1; m++)
{
flag = 0;
for (j = 0; j < len - 1; j++)
{
if (array[j] > array[j + 1])
{
flag = 1;
temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; count++;
}
}
}
cout << count << endl;
}
int Partition(int* array, int low, int high, int len)
{
array[0] = array[low]; int temp = array[low];
while (low < high)
{
while (low < high && array[high] >= temp) --high;
array[low] = array[high];
while (low < high && array[low] <= temp) ++low;
array[high] = array[low];
}
array[low] = array[0];
display_from1(array, len);
return low;
}
void quickSort(int* array, int low, int high, int len)
{
if (low < high)
{
int pivotloc = Partition(array, low, high, len);
quickSort(array, low, pivotloc - 1, len);
quickSort(array, pivotloc + 1, high, len);
}
}
void EasySelectSort(int* array, int len)
{
for (int i = 1; i <= len; ++i)
{
int k = i, temp;
for (int j = i + 1; j <= len; j++)
{
if (array[j] < array[k]) k = j;
}
if (k != i)
{
temp = array[i]; array[i] = array[k]; array[k] = temp;
}
display_from1(array, len);
}
cout << endl;
}
void HeapAdjust(vector<int> &H, int s, int m)
{
int rc = H[s];
for (int j = 2 * s; j <= m; j *= 2)
{
if (j < m && H[j] > H[j + 1])++j;
if (rc <= H[j]) break;
H[s] = H[j]; s = j;
}
H[s] = rc;
}
void HeapSort(vector<int> H, int len)
{
int i;
for (i = len / 2; i > 0; i--)
{
HeapAdjust(H, i, len);
}
display_from1_vector(H, len);
for (i = len; i > 1; i--)
{
swap(H[1], H[i]);
HeapAdjust(H, 1, i - 1);
display_from1_vector(H, len);
}
}
int main()
{
int len;
cin >> len;
vector<int> array(len + 1);
for (int i = 1; i <= len; i++)
{
cin >> array[i];
}
HeapSort(array, len);
//}
return 0;
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
