YTU算法学习——排序

Rubisco..

已于 2025-04-16 23:30:34 修改

阅读量324

点赞数 5

文章标签：算法排序算法

于 2025-04-09 21:07:44 首次发布

本文链接：https://blog.csdn.net/2401_88110477/article/details/146986149

版权

1.冒泡法排序

题目描述

用冒泡法对输入的 10 个字符从小到大排序。

输入

长度为 10的字符串，仅包含字母，数字。

输出

按 ASCII 排好序的字符串

输入输出样例

样例输入 #1

qwertyuiop

样例输出 #1

eiopqrtuwy

代码：

#include<iostream>
#define N 10
using namespace std;
int main()
{
	char a[N + 1];
	int m, i, j;
	cin.getline(a, N + 1);//输入
	for (i = 0; i < N - 1; i++)//冒泡排序
	{
		for (j = 0; j < N - 1 - i; j++)
		{
			if (a[j] > a[j + 1])
			{
				char ch = a[j];
				a[j] = a[j + 1];
				a[j + 1] = ch;
			}
		}
	}
	for (i = 0; i < N; i++)//输出
	{
		cout << a[i];
	}
	cout << endl;
	return 0;
}

2.快速排序法：

题目描述

以某个数为标准，把比这个数大的都移到它的后面，比这个数小的都移到它的前面，这样它后面的任意一个数都比它前面的任意一个数大，再将这前后两组数再分别重复这一过程，最后就会得到有序的数列；

补充：如果从大到小排列可以将比这个数大的都移到它的前面，比这个数小的都移到它的后面.

快速排序从小到大排序算法描述：

1）设置两个变量first、last,令first等于一组数的第一个数的下标，last等于一组数的最后一个数的下标；

2）以某个数组元素作为关键数据（这里将这组数的第一个数作为关键数据），赋值给key，即key=A[first]；

3）从last开始向前搜索，即由后开始向前搜索(last--)，找到第一个小于key的值A[last]，将A[last]给A[first]；

4）从first开始向后搜索，即由前开始向后搜索(first++)，找到第一个大于key的A[first]，将A[first]给A[last]；

5）重复第3、4步，直到first=last，将key的值给a[first]；

6）将first两边的两组数分别再进行排序,重复1、2、3、4、5步；直到每组只剩一个数排序结束.

现在，我们的题目来了...

输入一组整数，将这组整数从小到大排列。

输入

输入n和n个整数

输出

从小到大输出

输入输出样例

样例输入 #1

10
2 1 3 5 4 6 8 7 9 10

样例输出 #1

1 2 3 4 5 6 7 8 9 10

代码：

#include<iostream>
using namespace std;
void Quicksort(int a[], int low, int high)
{
    int first = low;
    int last = high;
    int key = a[first];
    if (low >= high)
    {
        return;
    }
    while(first<last)
    {
        while (a[last] >= key&&first<last)
        {
            last--;
         }
        a[first] = a[last];
        while (a[first] <= key && first < last)
        {
            first++;
        }
        a[last] = a[first];
    }
    a[first] = key;
    Quicksort(a, low, first - 1);
    Quicksort(a, last + 1, high);
}
int main()
{
    int i, a[100], x, n = 0;
    cin >> n;
    for (i = 0; i < n; i++)
        cin >> a[i];
    Quicksort(a, 0, n - 1);
    for (i = 0; i <= n - 1; i++)
        cout << a[i] << " ";
    cout << endl;
    return 0;
}

3.快速排序法的递归实现：

题目描述

输入

一列整数

输出

从小到大排序的数列

输入输出样例

样例输入 #1

11 55 14 63 88 47 31 24 11 0

样例输出 #1

0 11 11 14 24 31 47 55 63 88

代码：

#include<iostream>
#define LENTH 10
using namespace std;
int AdjustArray(int s[], int left, int right)
{
	int i = left, j = right;
	int key = s[left];
	while (i < j)
	{
		while (s[j] >= key && i < j)
		{
			j--;
		}
		if(i<j)s[i++] = s[j];
		while (i < j && s[i] <= key)
		{
			i++;
		}
		if(i<j)s[j--] = s[i];
		
	}
	s[i] = key;
	return i;
}
void QuickSort(int s[], int left, int right)
{
	if (left >= right)
	{
		return;
	}
	int mark = AdjustArray(s, left, right);
	QuickSort(s, left, mark - 1);
	QuickSort(s, mark + 1, right);
}
int main()
{
	int arr[LENTH];
	for (int i = 0; i < LENTH; i++)
	{
		cin >> arr[i];
	}
	QuickSort(arr, 0, LENTH - 1);
	for(int i=0;i<LENTH;i++)
	{
		cout << arr[i]<<" ";
	}
	cout << endl;
	return 0;
}

4.堆排序:

输入

输入n和n个整数

输出

从小到大输出

输入输出样例

样例输入 #1

10
2 1 3 4 6 5 7 9 8 10

样例输出 #1

1 2 3 4 5 6 7 8 9 10

代码：

#include<iostream>
using namespace std;
void HeapAdjust(int arr[], int i, int n)
{
	arr[0] = arr[i];
	for (int j = i * 2; j <= n; j *= 2)
	{
		if (j<n&&arr[j] < arr[j + 1])
		{
			j++;
		}
		if (arr[j] < arr[0])break;
		else
		{
			arr[i] = arr[j];
			i = j;
		}
	}
	arr[i] = arr[0];
}
void HeapSort(int arr[],int n)
{
	for (int i = n / 2; i >= 1; i--)
	{
		HeapAdjust(arr, i, n);
	}
	for (int j = n; j > 1; j--)
	{
		int temp = arr[1];
		arr[1] = arr[j];
		arr[j] = temp;
		HeapAdjust(arr, 1, j - 1);
	}
}
int main()
{
	int n, arr[100];
	cin >> n;
	for (int i = 1; i <= n; i++)
	{
		cin >> arr[i];
	}
	HeapSort(arr, n);
	for (int i = 1; i <= n; i++)
	{
		cout << arr[i] << ' ';
	}
	cout << endl;
	return 0;
}

5.归并排序 :

输入

n和n个整数

输出

从小到大排序

输入输出样例

样例输入 #1

10
2 1 3 5 4 6 7 9 8 10

样例输出 #1

1 2 3 4 5 6 7 8 9 10

代码：

#include<iostream>
#include<cstring>
using namespace std;
void Merge(int arr[],int temp[], int begin, int mid, int end)
{
	int i = begin, j = mid+1, k = begin;
	while (i != mid + 1 && j != end + 1)
	{
		if (arr[i] > arr[j])
			temp[k++] = arr[j++];
		if (arr[i] <= arr[j])
			temp[k++] = arr[i++];
	}
	while (j != end + 1)
	{
		temp[k++] = arr[j++];
	}
	while (i != mid + 1)
	{
		temp[k++] = arr[i++];
	}
	for (int r = begin; r <= end; r++)
	{
		arr[r] = temp[r];
	}
}
void MergeSort(int arr[], int temp[], int begin, int end)
{
	if (begin < end)
	{
		int mid = begin + (end - begin) / 2;
		MergeSort(arr, temp, begin, mid);
		MergeSort(arr, temp, mid + 1, end);
		Merge(arr, temp, begin, mid, end);
	}
}
int main()
{
	int  n, arr[100];
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		cin >> arr[i];
	}
	int temp[100];
	memset(temp, 0, sizeof(temp));
	MergeSort(arr,temp,0,n-1);
	for (int i = 0; i < n; i++)
	{
		cout << arr[i] << ' ';

	}
	cout << endl;
	return 0;
}

6.希尔排序：

题目描述

给你10个数，设计一个程序，实现希尔插入排序算法，并输出这个序列的希尔排序过程。

输入

1行10个数，两个数之间有空格隔开，所有数均不超过10910^9109

输出

每个排序过程输出一行，直到排序完成。

输入输出样例

样例输入 #1

9 8 7 6 5 4 3 2 1 0

样例输出 #1

4 3 2 1 0 9 8 7 6 5
0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9

代码：

#include<iostream>
using namespace std;
int main()
{
    int arr[12];
    for (int i = 1; i <= 10; i++)
    {
        cin >> arr[i];
    }
    int d, j;
    for (d = 10 / 2; d >= 1; d = d / 2)
    {
        for (int i = d + 1; i <= 10; i++)
        {
            if (arr[i] < arr[i - d])
            {
                arr[0] = arr[i];
                for (j = i - d; j > 0 && arr[0] < arr[j]; j -= d)
                {
                    arr[j + d] = arr[j];

                }
                arr[j + d] = arr[0]; 
            }
        }
        for (int k = 1; k <= 10; k++)
        {
            cout << arr[k] << ' ';
        }
        cout << endl; 
    }
    return 0;
}

7.基数排序：

输入

输入n和n个整数

输出

从小到大排序

输入输出样例

样例输入 #1

10
2 1 3 4 6 5 7 9 8 10

样例输出 #1

1 2 3 4 5 6 7 8 9 10

代码：

#include <iostream>
#include <string.h>
using namespace std;
/* 获取输入数字的索引值，order指定需要获取哪一位的索引，1代表个位，2代表十位，3代表百位 */
int get_index(int num, int order)
{
    while(--order)
        num/=10;
    return num%10;
}
/* 进行基数排序 */
void radix_sort(int arr[], int len, int dec, int order)
{
    int i, j;
    int index;                      /* 排序索引 */
    int tmp[1001];                  /* 临时数组，用来保存待排序的中间结果 */
    int num[10];                    /* 保存索引值的数组 */
    memset(num, 0, 10*sizeof(int)); /* 数组初始清零 */
    memset(tmp, 0, len*sizeof(int));/* 数组初始清零 */
    if (dec < order)                /* 最高位排序完成后返回 */
        return;
    for (i=0; i<len; i++)
    {
        index = get_index(arr[i],order);    /* 获取索引值 */
        num[index]++;                       /* 对应位加一 */
    }
    for (i=1; i<10; i++)
        num[i] += num[i-1];                 /* 调整索引数组 */
    for (i=len-1; i>=0; i--)
    {
        index = get_index(arr[i], order);/* 从数组尾开始依次获得各个数字的索引 */
        j = --num[index];                   /* 根据索引计算该数字在按位排序之后在数组中的位置 */
        tmp[j] = arr[i];                    /* 数字放入临时数组 */
    }
    for (i=0; i<len; i++)
        arr[i] = tmp[i];                                     /* 从临时数组复制到原数组 */
    // 继续按高一位的数字大小进行排序
    radix_sort(arr, len, dec, order + 1);
    return;
}
int main()
{
    int i,n;
    int arr[1001];
    cin>>n;
    for(i=0; i<n; i++)
        cin>>arr[i];
    int dec=3;      /* 最多处理位数 */
    int order= 1;   /* 排序的位数，1代表个位、2代表十位、3代表百位 */
    /* 排序函数，从个位开始 */
    radix_sort(arr, n, dec, order);
    for (i=0; i<n; i++)
        cout<<arr[i]<<" ";
    cout<<endl;
    return 0;
}