第九课 排序

最新推荐文章于 2024-06-01 23:14:10 发布
最新推荐文章于 2024-06-01 23:14:10 发布
阅读量235 收藏
点赞数
分类专栏： C++刷题 文章标签： 算法 数据结构 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BH04250909/article/details/133645932
版权

文章目录

第九课 排序

排序算法

image-20231007161146336

image-20231007161221689

image-20231007161255331

image-20231007161345682

img

image-20231007161402458

image-20231007161428771

image-20231007161441532

image-20231007161454299

image-20231007161510826

快速排序算法动画演示_哔哩哔哩_bilibili

image-20231007161539374

image-20231007161558662

image-20231007161616925

image-20231007161640929

lc912.排序数组–中等

题目描述

给你一个整数数组 nums，请你将该数组升序排列。

示例 1：

输入：nums = [5,2,3,1]
输出：[1,2,3,5]

示例 2：

输入：nums = [5,1,1,2,0,0]
输出：[0,0,1,1,2,5]

提示：

  • 1 <= nums.length <= 5 * 104
  • -5 * 104 <= nums[i] <= 5 * 104

代码展示

class Solution {
public:       //堆排序——不会超时
    vector<int> sortArray(vector<int>& nums) {
        heapSort(nums);
        return nums;
    }

private:
    void heapify(vector<int>& nums, int n, int i) {
        int largest = i;
        int left = 2 * i + 1;
        int right = 2 * i + 2;

        if (left < n && nums[left] > nums[largest])
            largest = left;

        if (right < n && nums[right] > nums[largest])
            largest = right;

        if (largest != i) {
            swap(nums[i], nums[largest]);
            heapify(nums, n, largest);
        }
    }

    void heapSort(vector<int>& nums) {
        int n = nums.size();

        // 建立最大堆
        for (int i = n / 2 - 1; i >= 0; i--)
            heapify(nums, n, i);

        // 逐步提取元素
        for (int i = n - 1; i > 0; i--) {
            swap(nums[0], nums[i]);
            heapify(nums, i, 0);
        }
    }
};

class Solution {
public:       //归并排序也可以
    vector<int> sortArray(vector<int>& nums) {
        vector<int> tmp(nums.size());
        mergeSort(nums, tmp, 0, nums.size() - 1);
        return nums;
    }

private:
    void merge(vector<int>& nums, vector<int>& tmp, int left, int mid, int right) {
        int i = left;
        int j = mid + 1;
        int k = left;

        while (i <= mid && j <= right) {
            if (nums[i] <= nums[j]) {
                tmp[k++] = nums[i++];
            } else {
                tmp[k++] = nums[j++];
            }
        }

        while (i <= mid) {
            tmp[k++] = nums[i++];
        }

        while (j <= right) {
            tmp[k++] = nums[j++];
        }

        for (int l = left; l <= right; l++) {
            nums[l] = tmp[l];
        }
    }

    void mergeSort(vector<int>& nums, vector<int>& tmp, int left, int right) {
        if (left < right) {
            int mid = left + (right - left) / 2;
            mergeSort(nums, tmp, left, mid);
            mergeSort(nums, tmp, mid + 1, right);
            merge(nums, tmp, left, mid, right);
        }
    }
};

lc1122.数组的相对排序–简单

题目描述

给你两个数组，arr1 和 arr2，arr2 中的元素各不相同，arr2 中的每个元素都出现在 arr1 中。

对 arr1 中的元素进行排序，使 arr1 中项的相对顺序和 arr2 中的相对顺序相同。未在 arr2 中出现过的元素需要按照升序放在 arr1 的末尾。

示例 1：

输入：arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]
输出：[2,2,2,1,4,3,3,9,6,7,19]

示例 2:

输入：arr1 = [28,6,22,8,44,17], arr2 = [22,28,8,6]
输出：[22,28,8,6,17,44]

提示：

  • 1 <= arr1.length, arr2.length <= 1000
  • 0 <= arr1[i], arr2[i] <= 1000
  • arr2 中的元素 arr2[i] 各不相同
  • arr2 中的每个元素 arr2[i] 都出现在 arr1 中

image-20231007162610016

代码展示

你可以使用自定义比较函数来解决这个问题，首先建立一个哈希表，将arr2中的元素与其对应的位置映射起来。然后，使用自定义的比较函数对arr1进行排序，排序规则如下：

  1. 如果a和b都在arr2中，比较它们在arr2中的位置，位置靠前的元素排在前面。
  2. 如果a和b都不在arr2中，直接比较它们的大小。

以下是示例代码：

class Solution {
public:
    vector<int> relativeSortArray(vector<int>& arr1, vector<int>& arr2) {
        unordered_map<int, int> position;
        for (int i = 0; i < arr2.size(); i++) {
            position[arr2[i]] = i;
        }
        
        sort(arr1.begin(), arr1.end(), [&](int a, int b) {
            if (position.count(a) && position.count(b)) {
                return position[a] < position[b];
            } else if (position.count(a)) {
                return true;
            } else if (position.count(b)) {
                return false;
            } else {
                return a < b;
            }
        });
        
        return arr1;
    }
};

这段代码首先建立了一个哈希表 position，将arr2中的元素与其对应的位置映射起来。然后，使用自定义的比较函数对arr1进行排序，按照上述规则进行比较。这样就能够保证arr1中的元素按照arr2中的相对顺序排列，未在arr2中出现的元素按照升序排在末尾。

如果你想自己实现排序函数，你可以使用计数排序的方法，首先统计arr1中每个元素的出现次数，然后根据arr2的顺序构建排序后的结果。

以下是示例代码：

class Solution {
public:
    vector<int> relativeSortArray(vector<int>& arr1, vector<int>& arr2) {
        // 统计arr1中每个元素的出现次数
        vector<int> count(1001, 0);
        for (int num : arr1) {
            count[num]++;
        }
        
        vector<int> result;
        // 根据arr2的顺序构建排序后的结果
        for (int num : arr2) {
            while (count[num] > 0) {
                result.push_back(num);
                count[num]--;
            }
        }
        
        // 处理arr2中没有的元素
        for (int i = 0; i <= 1000; i++) {
            while (count[i] > 0) {
                result.push_back(i);
                count[i]--;
            }
        }
        
        return result;
    }
};

这段代码首先使用 count 数组统计了arr1中每个元素的出现次数。然后，根据arr2的顺序构建了排序后的结果，并将结果存储在 result 数组中。最后，处理arr2中没有的元素，将它们按照升序添加到 result 数组中。

这样就能够实现按照arr2的相对顺序对arr1进行排序。

lc56.合并区间–中等

题目描述

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。

示例 1：

输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

示例 2：

输入：intervals = [[1,4],[4,5]]
输出：[[1,5]]
解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。

提示：

  • 1 <= intervals.length <= 104
  • intervals[i].length == 2
  • 0 <= starti <= endi <= 104

image-20231007162657349

代码展示

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        if (intervals.empty()) {
            return {};
        }

        // 对区间进行双关键字排序（按左端点升序，右端点升序）
        sort(intervals.begin(), intervals.end(), [](const vector<int>& a, const vector<int>& b) {
            return a[0] == b[0] ? a[1] < b[1] : a[0] < b[0];
        });

        vector<vector<int>> mergedIntervals;
        mergedIntervals.push_back(intervals[0]);

        // 扫描合并
        for (int i = 1; i < intervals.size(); i++) {
            vector<int>& currentInterval = intervals[i];
            vector<int>& previousInterval = mergedIntervals.back();

            if (currentInterval[0] <= previousInterval[1]) {
                // 当前区间和前一个区间重叠，合并区间
                previousInterval[1] = max(previousInterval[1], currentInterval[1]);
            } else {
                // 当前区间和前一个区间不重叠，将当前区间添加到结果中
                mergedIntervals.push_back(currentInterval);
            }
        }

        return mergedIntervals;
    }
};

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        /*[1, 5]  [2, 6] [3, 4] [6, 10]  [11 12]
           1 2 3 4 5 6 7 8 9 10 11 12
           1 1 1 1 1
             1 1 1 1 1
               1 1
                     1 1 1 1  1
                                  1 1
           
           +1      -1
             +1      -1
               +1-1
                     +1        -1
                               +1 -1
         count: 0
        把从1覆盖到5这个区间，看作2个事件：
        (a) 在1处，有一个事件：开始覆盖（次数+1）
        (b) 在5处，有一个事件：结束覆盖（次数-1）
        */
        // 产生2n个事件
        // 时间位置，时间情况(+1/-1)
        vector<pair<int,int>> events;
        for (vector<int>& interval : intervals) {
            // 差分
            events.push_back(make_pair(interval[0], 1));
            events.push_back(make_pair(interval[1], -1));
        }
        sort(events.begin(), events.end(),
             [](pair<int,int>& a, pair<int,int>& b) {
                 // 1 在 -1 之前（如果差分是闭区间[1,5]而不是前闭后开[1,6)的话
                 return a.first < b.first || (a.first == b.first && a.second > b.second);
             });
        int count = 0;
        int left;
        vector<vector<int>> ans;
        for (pair<int,int>& event : events) {
            if (count == 0) // 加之前是0，加之后是非0
                left = event.first;  // 一个段的产生
            count += event.second;
            if (count == 0) // 非零变零，一个段的结束
                ans.push_back({left, event.first});
        }
        return ans;
    }
};

lc215.数组中的第k个最大元素–中等

题目描述

给定整数数组 nums 和整数 k，请返回数组中第 **k** 个最大的元素。

请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。

示例 1:

输入: [3,2,1,5,6,4], k = 2
输出: 5

示例 2:

输入: [3,2,3,1,2,4,5,5,6], k = 4
输出: 4

提示：

  • 1 <= k <= nums.length <= 105
  • -104 <= nums[i] <= 104

代码展示

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        int left = 0;
        int right = nums.size() - 1;
        
        while (left <= right) {
            int pivotIndex = partition(nums, left, right);
            if (pivotIndex == k - 1) {
                return nums[pivotIndex];
            } else if (pivotIndex < k - 1) {
                left = pivotIndex + 1;
            } else {
                right = pivotIndex - 1;
            }
        }
        
        return -1; // 如果输入无效或 k 超出范围，可以返回一个特殊值
    }

    int partition(vector<int>& nums, int left, int right) {
        int pivot = nums[left];
        int l = left + 1;
        int r = right;
        
        while (l <= r) {
            if (nums[l] < pivot && nums[r] > pivot) {
                swap(nums[l++], nums[r--]);
            }
            if (nums[l] >= pivot) l++;
            if (nums[r] <= pivot) r--;
        }
        
        swap(nums[left], nums[r]);
        return r;
    }
};

acwing104.货仓选址–简单

题目描述

image-20231007163635776

代码展示

#include <algorithm>

using namespace std;

const int N = 100005;

int n, res;
int a[N];

int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; i ++ ) scanf("%d", &a[i]);

    sort(a, a + n);

    for (int i = 0; i < n; i ++ ) res += abs(a[i] - a[n >> 1]);
    printf("%d\n", res);

    return 0;
}

lc493.翻转树–困难

题目描述

给定一个数组 nums ，如果 i < j 且 nums[i] > 2*nums[j] 我们就将 (i, j) 称作一个*重要翻转对*。

你需要返回给定数组中的重要翻转对的数量。

示例 1:

输入: [1,3,2,3,1]
输出: 2

示例 2:

输入: [2,4,3,5,1]
输出: 3

注意:

  1. 给定数组的长度不会超过50000。
  2. 输入数组中的所有数字都在32位整数的表示范围内。

代码展示

class Solution {
public:
    int reversePairs(vector<int>& nums) {
        int n = nums.size();
        if (n <= 1) {
            return 0; // 如果数组长度小于等于1，不存在翻转对
        }

        vector<int> temp(n); // 用于归并排序的辅助数组
        return mergeSort(nums, temp, 0, n - 1);
    }

    int mergeSort(vector<int>& nums, vector<int>& temp, int left, int right) {
        if (left >= right) {
            return 0; // 当子数组长度为1时，不再拆分，返回0
        }

        int mid = left + (right - left) / 2;
        int count = mergeSort(nums, temp, left, mid) + mergeSort(nums, temp, mid + 1, right);

        int i = left; // 左子数组的起始位置
        int j = mid + 1; // 右子数组的起始位置
        int k = left; // 辅助数组的起始位置

        // 统计翻转对的数量
        while (i <= mid) {
            while (j <= right && static_cast<long long>(nums[i]) > 2LL * nums[j]) {
                j++;
            }
            count += (j - (mid + 1)); // 统计右子数组中满足条件的元素数量
            i++;
        }

        // 归并排序合并两个子数组，并保持有序性
        i = left;
        j = mid + 1;
        while (i <= mid && j <= right) {
            if (nums[i] <= nums[j]) {
                temp[k++] = nums[i++];
            } else {
                temp[k++] = nums[j++];
            }
        }
        while (i <= mid) {
            temp[k++] = nums[i++];
        }
        while (j <= right) {
            temp[k++] = nums[j++];
        }

        for (i = left; i <= right; i++) {
            nums[i] = temp[i];
        }

        return count;
    }
};

要解决这个问题，可以使用归并排序的思想来统计重要翻转对的数量。具体步骤如下：

  1. 将原始数组拆分成两个子数组。
  2. 分别对两个子数组进行排序。
  3. 遍历其中一个子数组的元素，并查找另一个子数组中满足条件的元素，以统计重要翻转对的数量。
  4. 合并两个子数组时，继续维护它们的有序性。

这段代码首先将原始数组拆分成两个子数组，然后对这两个子数组分别进行归并排序。在归并排序的过程中，统计满足条件的翻转对的数量，并在合并时维护子数组的有序性。最终，返回翻转对的数量。时间复杂度为O(n*log(n))。

lc327.区间个数–困难

题目描述

给你一个整数数组 nums 以及两个整数 lower 和 upper 。求数组中，值位于范围 [lower, upper] （包含 lower 和 upper）之内的 区间和的个数 。

区间和 S(i, j) 表示在 nums 中，位置从 i 到 j 的元素之和，包含 i 和 j (i ≤ j)。

示例 1：

输入：nums = [-2,5,-1], lower = -2, upper = 2
输出：3
解释：存在三个区间：[0,0]、[2,2] 和 [0,2] ，对应的区间和分别是：-2 、-1 、2 。

示例 2：

输入：nums = [0], lower = 0, upper = 0
输出：1

提示：

  • 1 <= nums.length <= 105
  • -231 <= nums[i] <= 231 - 1
  • -105 <= lower <= upper <= 105
  • 题目数据保证答案是一个 32 位 的整数

代码展示

class Solution {
public:
    int countRangeSum(vector<int>& nums, int lower, int upper) {
        int n = nums.size();
        vector<long long> prefixSum(n + 1, 0);
        for (int i = 0; i < n; i++) {
            prefixSum[i + 1] = prefixSum[i] + nums[i];
        }
        return countAndMerge(prefixSum, 0, n, lower, upper);
    }

    int countAndMerge(vector<long long>& prefixSum, int left, int right, int lower, int upper) {
        if (left == right) {
            return 0; // 递归结束条件
        }
        int mid = left + (right - left) / 2;
        int count = countAndMerge(prefixSum, left, mid, lower, upper) +
                    countAndMerge(prefixSum, mid + 1, right, lower, upper);

        int i = left;
        int j = mid + 1;
        int k = mid + 1;
        while (i <= mid) {
            while (j <= right && prefixSum[j] - prefixSum[i] < lower) {
                j++;
            }
            while (k <= right && prefixSum[k] - prefixSum[i] <= upper) {
                k++;
            }
            count += (k - j);
            i++;
        }

        // 归并排序
        vector<long long> sorted(right - left + 1, 0);
        int p1 = left;
        int p2 = mid + 1;
        int p = 0;
        while (p1 <= mid || p2 <= right) {
            if (p1 > mid) {
                sorted[p++] = prefixSum[p2++];
            } else if (p2 > right) {
                sorted[p++] = prefixSum[p1++];
            } else {
                if (prefixSum[p1] < prefixSum[p2]) {
                    sorted[p++] = prefixSum[p1++];
                } else {
                    sorted[p++] = prefixSum[p2++];
                }
            }
        }

        for (int i = 0; i < sorted.size(); i++) {
            prefixSum[left + i] = sorted[i];
        }

        return count;
    }
};

要解决这个问题，可以使用归并排序和前缀和的结合方法。具体步骤如下：

  1. 计算前缀和数组 prefixSum，其中 prefixSum[i] 表示 nums 数组中前 i 个元素的和。
  2. 定义一个递归函数 countAndMerge 用于统计区间和个数并归并排序 prefixSum 数组。
  3. 在 countAndMerge 函数中，首先计算中间索引 mid，然后递归计算左半部分和右半部分的区间和个数。
  4. 接下来，合并左半部分和右半部分的区间和，统计符合要求的区间和个数。
  5. 最后，返回区间和个数。

这段代码首先计算前缀和数组 prefixSum，然后使用递归函数 countAndMerge 统计区间和个数并归并排序 prefixSum 数组。在 countAndMerge 函数中，通过归并排序合并左半部分和右半部分的区间和，同时统计满足要求的区间和个数。最终，返回区间和个数。时间复杂度为O(n*log(n))。

image-20231007164248984
BH04250909
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构基础系列(9)：排序
06-08
数据结构课程是计算机类专业的专业基础课程，在IT人才培养中，起着重要...系列课程包含11个部分，本课为第9部分排序，介绍插入排序、交换排序、选择排序、归并排序、基数排序等各种排序算法，以及各种算法的性能分析。
堆排序算法
翔云
12-03 228
本文主要介绍堆排序的原理、例子以及代码实现。
数据结构教程（共四十课）
04-16
第九课：循环链表与双向链表 第十课：栈的表示与实现 第十一课：栈的应用 第十二课：实验二 循环链表实验 第十三课：队列 第十四课：串的定义 第十五课：串的表示和实现 第十六课：串操作应用举例 第十七课...
数据结构和算法导学（计算机必修课）
12-21
数据结构和算法导学 第一章 概论 第二章 线性表 第三章 栈和队列 第四章 串 第五章 多多维数组和广义表 第六章 树 第七章 图 第八章 排序 第九章 查找 第十章 文件
Tableau 数据可视化与实战 118课.txt
05-14
Tableau 数据可视化与实战 118课 课程目录： 第1章: Tableau数据可视化应用实战 1.本门课程目录 2.本门课程目标 3.Tableau概述_什么是数据可视化？ 4.Tableau概述_如何用图表讲故事？(1) 5.Tableau概述_Tableau发展...
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 542
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
算法训练营day41
stmfresher的博客
05-27 385
动态规划理论基础（主要就是确定动态规划的几个步骤）
Java多线程（04）—— 保证线程安全的方法与线程安全的集合类
2201_75456895的博客
05-30 1185
其含义为：CAS(M, A, B);M 表示内存，A 和 B 分别表示一个寄存器；如果 M 的值和 A 的值相同，则把 M 和 B 的值交换，如果不同，则无事发生；因为，因此可以基于 CAS 指令，不进行加锁，来编写线程安全代码；CAS 指令操作经过操作系统，JVM 的层层封装，最后 Java 标准库，提供了一些工具类，其中最主要工具类就是由于原子类内部用的是 CAS 实现，所以性能要比加锁实现高很多；在包下；
一千题，No.0037（组个最小数）
2301_76783671的博客
05-29 727
给定数字 0-9 各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意 0 不能做首位）。例如：给定两个 0，两个 1，三个 5，一个 8，我们得到的最小的数就是 10015558。输入在一行中给出 10 个非负整数，顺序表示我们拥有数字 0、数字 1、……整数间用一个空格分隔。10 个数字的总个数不超过 50，且至少拥有 1 个非 0 的数字。现给定数字，请编写程序输出能够组成的最小的数。在一行中输出能够组成的最小的数。
图形学初识--空间变换
航行的土豆的博客
05-29 876
介绍二维和三维下的变换矩阵以及常见的推导和理解方式。主要就是：平移、旋转、缩放
并查集拓展（扩展域并查集）
Qlarkstar的博客
05-29 950
事实证明，扩展域并查集应该在带权并查集前面讲的，因为比较好理解，而且回过头看带权并查集可能也会更轻松一些。
排序算法(一) 基础排序算法
Yerosius1的博客
05-31 726
排序本质：减小逆序对的过程在基础排序算法中，将待排序序列分为相对有序区与相对无序区。每次遍历到数组末尾称为一。
24.5.26（树链剖分板子，二分+线段树）
breath_of_yuan的博客
05-27 860
思路：可看出峰值的数量是固定的，为 n/2-1，头尾不可为峰，连续俩数不能都为峰，假如我们让奇数位置的值为峰( 除了头，发现如果p的 n值在偶数位，且挨着1，是无法实现的，但其实也不难解决，将p翻转后 n下标的奇偶性就会改变( 最后输出前记得翻转 q。如果只有偶数子节点，那么0/1的选择是固定的，如果存在奇节点，所有偶节点可以取更大值，对于奇节点的选择，如果偶数个奇节点，0/1各一半，如果奇数个，多的那个取父节点的反，将奇点的 0/1 差值排个序，贪心即可。easy线段树题 建平台。补重庆科技 C 二分。
代码随想录算法训练营第三十六 | ● 435. 无重叠区间 ● 763.划分字母区间 ● 56. 合并区间
最新发布
cir_sky的博客
06-01 368
贪心算法——区间问题
大气污染溯源算法及其技术实现
weixin_42496466的博客
05-29 1237
高斯分布由均值（μ）、方差（σ²）决定，公式为: [ f(x)=\frac{1}{\sqrt{2\pi\sigma^2}}e^{-\frac{(x-\mu)^2}{2\sigma^2}}]在环境模型中，高斯分布用来描述污染物浓度的概率分布，即在某一特定点的污染物浓度值的概率，随着距离污染源的距离增加而按高斯分布规律衰减小。相关性分析是统计学中一种重要的方法，用于研究两个或多个变量之间相互关系的性质，主要包括关系的方向（正相关或负相关）、强度以及是否存在线性。•偏相关：控制其他变量影响，分析两变量间净相关。
分析和设计算法
日积月累
05-29 295
分析和设计算法
偏微分方程算法之抛物型方程差分格式编程示例一
L_peanut的博客
05-27 248
主要对本专栏所介绍的抛物型偏微分方程的差分格式进行算例补充。
OOP一元多项式类（运算符重载）
zgy11026的博客
05-30 658
运算符重载
从键盘输入10个学生的某门课的成绩，计算平均成绩，并按平均成绩排序。
05-27
好的，这是一个关于计算和排序的问题。以下是一种可能的实现方式： ``` #include <stdio.h> int main() { int n = 10; // 学生人数 float scores[n]; // 成绩数组 float sum = 0; // 总成绩 // 从键盘读入成绩 for (int i = 0; i < n; i++) { printf("请输入第%d个学生的成绩：", i + 1); scanf("%f", &scores[i]); sum += scores[i]; } // 计算平均成绩 float average = sum / n; printf("平均成绩为：%.2f\n", average); // 冒泡排序 for (int i = 0; i < n - 1; i++) { for (int j = 0; j < n - i - 1; j++) { if (scores[j] < scores[j+1]) { float temp = scores[j]; scores[j] = scores[j+1]; scores[j+1] = temp; } } } // 输出排序后的成绩 printf("按平均成绩排序后的成绩为：\n"); for (int i = 0; i < n; i++) { printf("%.2f ", scores[i]); } printf("\n"); return 0; } ``` 运行结果示例如下： ``` 请输入第1个学生的成绩：90 请输入第2个学生的成绩：85 请输入第3个学生的成绩：92 请输入第4个学生的成绩：77 请输入第5个学生的成绩：88 请输入第6个学生的成绩：80 请输入第7个学生的成绩：95 请输入第8个学生的成绩：83 请输入第9个学生的成绩：87 请输入第10个学生的成绩：91 平均成绩为：87.80 按平均成绩排序后的成绩为： 95.00 92.00 91.00 90.00 88.00 87.00 85.00 83.00 80.00 77.00 ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值