c++学习笔记（11）

最新推荐文章于 2024-11-07 23:24:07 发布
最新推荐文章于 2024-11-07 23:24:07 发布
阅读量670 收藏 16
点赞数 15
文章标签： 算法 排序算法 c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A2321713932/article/details/136999210
版权

1.

冒泡排序是一种简单的排序算法，它通过重复地遍历要排序的数列，比较相邻的两个元素，如果它们的顺序错误就交换它们的位置。冒泡排序的时间复杂度为O(n^2)。

以下是冒泡排序的详细解析和代码示例：

  1. 从第一个元素开始，依次比较相邻的两个元素，如果它们的顺序错误就交换它们的位置。这样，每一轮循环后，最大的元素就会被“冒泡”到数列的末尾。

  2. 重复步骤1，直到整个数列都被排序。

代码示例：

#include <iostream>
using namespace std;

void bubbleSort(int a[], int n) {
    for(int i = n;i >= 1; -- i)
    {
        for(int j = 1;j < i; ++ j)
        {
            if(a[j] > a[j + 1]) swap(a[j], a[j + 1]);
        }
    }
}

int main() {

    int a[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(a) / sizeof(a[0]);

    bubbleSort(a, n);

    cout << "Sorted array is: ";
    for (int i = 0; i < n; i++) {
        cout << a[i] << " ";
    }
    cout << endl;
    return 0;
}

2.

选择排序是一种简单的排序算法，它的基本思想是每次从未排序的元素中选出最小（或最大）的一个元素，将其放到已排序序列的末尾。选择排序的时间复杂度为O(n^2)。

以下是选择排序的详细解析和代码示例：

  1. 从第一个元素开始，依次遍历未排序的元素，找到其中最小的元素。

  2. 将找到的最小元素与未排序序列的第一个元素交换位置。

  3. 重复步骤1和步骤2，直到整个序列都被排序。

代码示例：

#include <iostream>
using namespace std;

void selectionSort(int arr[], int n)
{
    // 选择排序
    for(int i = n;i >= 1; -- i)
    {
        int max_id = 1;
        for(int j = 1;j <= i; ++ j)
        {
            if(arr[j] > arr[max_id])max_id = j;
        }
        swap(arr[j], arr[max_id]);
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);

    selectionSort(arr, n);

    cout << "Sorted array is: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    return 0;
}

3.

插入排序是一种简单的排序算法，它的基本思想是将一个元素插入到已经排好序的序列中，从而得到一个新的、更长的已排序序列。插入排序的时间复杂度为O(n^2)。

以下是插入排序的详细解析和代码示例：

  1. 从第二个元素开始，将其作为待插入的元素。

  2. 将待插入元素与已排序序列中的元素依次比较，找到合适的位置插入。

  3. 重复步骤1和步骤2，直到整个序列都被排序。

代码示例：

#include <iostream>
using namespace std;

void insertionSort(int arr[], int n) {
    // 插入排序
    for(int i = 2;i <= n; ++ i)
    {
        int val = arr[i], j;
        for(j = i;j > 1 && val < arr[j - 1]; -- j) arr[j] = arr[j - 1];

        a[j] = val;
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);

    insertionSort(arr, n);

    cout << "Sorted array is: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    return 0;
}

4.

快速排序是一种高效的排序算法，它的基本思想是通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比另一部分的所有数据要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

分区（partition）是快速排序算法中的一个重要操作，用于将数组分成两个部分，使得左边的元素都小于等于基准元素，右边的元素都大于等于基准元素。

  1. 选择一个基准元素，通常选择第一个元素或者最后一个元素。

  2. 将基准元素放到数组的最右边。

  3. 从左到右遍历数组，如果当前元素小于等于基准元素，则将其与左边的边界元素交换位置，并将左边界向右移动一位。

  4. 遍历完数组后，将基准元素与左边界的前一个元素交换位置。

  5. 返回基准元素的位置。

代码示例：

#include <iostream>
using namespace std;

int partition(int arr[], int low, int high) {
    int pivot = arr[high]; // 选择最后一个元素作为基准元素
    int i = low - 1; // 左边界
    for (int j = low; j <= high - 1; j++) {
        if (arr[j] <= pivot) {
            i++;
            swap(arr[i], arr[j]); // 将小于等于基准元素的元素交换到左边
        }
    }
    swap(arr[i + 1], arr[high]); // 将基准元素放到正确的位置
    return i + 1; // 返回基准元素的位置
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);
    int pivotIndex = partition(arr, 0, n - 1);

    cout << "Pivot element is at index: " << pivotIndex << endl;
    cout << "Array after partition: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    return 0;
}

快速排序的解析和代码示例：

  1. 选择一个基准元素，通常选择第一个元素或者最后一个元素。

  2. 通过一趟排序将待排序的数据分割成独立的两部分，所有比基准元素小的元素放在基准元素前面，所有比基准元素大的元素放在基准元素的后面（相同的数可以到任何一边）。在这个分割结束之后，对基准元素的排序就已经完成。

  3. 对前后两部分的数据进行递归调用快速排序。

代码示例：

#include <iostream>
using namespace std;

int partition(int arr[], int low, int high) {
    int pivot = arr[low]; // 选择第一个元素作为基准元素
    while (low < high) {
        while (low < high && arr[high] >= pivot) {
            high--;
        }
        arr[low] = arr[high]; // 将比基准元素小的元素交换到前面
        while (low < high && arr[low] <= pivot) {
            low++;
        }
        arr[high] = arr[low]; // 将比基准元素大的元素交换到后面
    }
    arr[low] = pivot; // 将基准元素放到正确的位置
    return low;
}

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pivotIndex = partition(arr, low, high); // 获取基准元素的位置
        quickSort(arr, low, pivotIndex - 1); // 对前半部分进行递归排序
        quickSort(arr, pivotIndex + 1, high); // 对后半部分进行递归排序
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);

    quickSort(arr, 0, n - 1);

    cout << "Sorted array is: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    return 0;
}

5.

归并排序是一种分治算法，它将待排序的序列分成两个子序列，对每个子序列进行排序，然后将两个已排序的子序列合并成一个有序序列。

  1. 将待排序的序列分成两个子序列，分别对它们进行排序。

  2. 将两个已排序的子序列合并成一个有序序列。

  3. 重复步骤1和步骤2，直到整个序列有序。

代码示例：

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 9;
int a[N], b[N];

void mergesort(int a[], int l, int r)
{
    if(l == r) return ;

    int mid = (l + r) / 2;
    mergesort(a, l, mid);
    mergesort(a, mid + 1, r);
    
    int pl = l, pr = mid + 1, pb = l;
    while(pl <= mid || pr <= r)
    {
        // 左半边已经放完
        if(pl > mid) b[pb ++] = a[pr ++ ];
        // 右半边已经放完
        else if(pr > r)b[pb ++] = a[pl ++];
        //两边都没有放完
        else
        {
            if(a[pl] < a[pr])b[pb ++] = a[pl ++];
            else b[pb ++ ] = a[pr ++ ];
        }
    }
    // 完成后复制回去
    for (int i = l;i <= r; ++ i)a[i] = b[i];
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n; cin >> n;
    for(int i = 1;i <= n; ++ i)cin >> a[i];

    mergesort(a, 1, n);

    for(int i = 1;i <= n; ++ i)cout << a[i] << " \n"[i == n];
    return 0;
}

6.

桶排序（Bucket sort）是一种非比较的排序算法。桶排序采用一些分类和分治的思想，把元素的值域分成若干段，每一段对应一个桶。在排序的时候，首先把每一个元素放到其对应的桶中，再对每一个桶中的元素分别排序，再按顺序把每个桶中的元素依次取出 ，合并成最终答案。

对于数据量较大但值域较小的数据，如N > 10的7次方, a[i] < 10的6次方,可以做到每一个值对应一个桶,桶排序的时间复杂度为o(n) 推荐使用桶排序 。

对于值域教大的数据，桶排序的时间复杂度与每个桶内排序方法有关，优势不明显，对于这种数据一般不使用桶排序 。

代码示例：

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 7;
int n;
int bucket[MAXN];

int main() {
    cin >> n;
    for (int i = 1; i <= n; i ++ ) {
        int x;
        cin >> x;
        bucket[x] ++;
    }
    for (int i = 0; i < MAXN; i ++ ) {
        for (int j = 1; j <= bucket[i]; j ++ )
            cout << i << " ";
    }
}

   

有趣的树人
关注
C++学习笔记本
05-14
C++学习笔记C++学习笔记C++学习笔记C++学习笔记C++学习笔记
c/c++再学习：排序算法了解
weixin_33805557的博客
12-04 89
1.冒泡排序 冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 算法描述 1.比较相邻的元素。如果第一个比第二个大，就交换它们两个； 2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一...
2020-11-04
qq_52232437的博客
11-08 115
一、基本原理 1.概念： 冒泡排序（Bubble Sort），是一种计算机领域的较简单的排序算法。 它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。 这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名。 2.算法原理: 冒泡排序算法的运作如下：（从后往前） 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一
数据结构与算法（冒泡排序）
sun_xiao_kai的博客
02-07 522
冒泡排序 冒泡排序是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把它们交换过来。遍历数列的工作是重复的进行直到没有在需要的交换，也就是说该数列已经排序完成，这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 冒泡算法的运作如下： 比较相邻的元素，如果第一个元素大于第二个元素（升序），就交换它们两个。 对每一对相邻元素做同样的工作，从开...
Go 数据结构排序之冒泡排序
u013919855的博客
06-15 132
冒泡排序（英语：Bubble Sort）是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 冒泡排序算法的运作如下： 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。 针对所有的元素重复以上的步骤，
C++学习笔记.pdf
08-12
C++学习笔记
C++学习笔记 示例编译运行
10-16
借斧砍柴。 这是学习范磊编著的《从新手到高手C++全方位学习》一书的笔记。其书中大部范例用Visual Studio 2022跑了一遍。愿对学习者有所帮助。
c++学习笔记.pdf
07-12
C++是一种静态类型、编译式、通用的编程语言，它支持过程化编程、面向对象编程和泛型编程。C++广泛应用于软件开发领域，包括操作...以上内容覆盖了C++语言中一些基础知识点，对于学习和理解C++编程具有重要的指导意义。
c++学习笔记精华版
08-27
### C++ 学习笔记精华版 #### 一、C++ 语言概述 **1、历史背景** - **C++ 的江湖地位** - Java、C、C++、Python、C# 是当前主流的编程语言之一，而 C++ 在这些语言中以其高效性和灵活性著称。 - **C++ 之父 ...
100种算法【Python版】第36篇——Graham Scan算法
AnFany
11-02 268
100种算法【Python版】第36篇——Graham Scan算法
算法基础-链表
August的专栏
11-05 216
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
weixin_66461496的博客
11-02 1037
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
字符串-06-整数与ip地址之间的转换
qq_45480682的博客
11-04 315
华为od算法——HJ33
【LeetCode】【算法】160.相交链表
passer__jw767的博客
11-05 284
Leetcode 160. 相交链表
【算法】（Python）贪心算法
yannan20190313的博客
11-04 1945
【算法】（Python）贪心算法（最大单元数，买卖股票最佳时机，最低加油次数）
二分查找习题篇(上)
最新发布
zoelinkailuo的博客
11-07 570
给定⼀个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。这里，我们把数组的元素分为两部分——小于等于target的部分[left,Bright] and 大于target的部分[Bright+1,right]。这里，我们把数组的元素分为两部分——平方后小于等于x的部分[1,mid] and 平方后大于x的部分[mid-1, x]和一个目标值，在数组中找到目标值，并返回其索引;
LeetCode每日一题3254---长度为 K 的子数组的能量值 I
niulinbiao的博客
11-06 311
输入：nums = [1,2,3,4,3,2,5], k = 3。输入：nums = [3,2,3,2,3,2], k = 2。输入：nums = [2,2,2,2,2], k = 4。[3, 4, 3] 中元素 不是 连续的。[4, 3, 2] 中元素 不是 上升的。[3, 2, 5] 中元素 不是 连续的。[1, 2, 3] 中最大元素为 3。[2, 3, 4] 中最大元素为 4。的，那么能量值为 最大 的元素。输出：[3,4,-1,-1,-1]输出：[-1,3,-1,3,-1]
二分查找算法—C++
2401_82677021的博客
11-03 399
关于求中点位置的操作什么时候需要加1，什么时候不需要。只需看下面的left和right ，如果出现-1，mid就需要加1。否则，不需要加1.
数组类算法【leetcode】
随便写写
11-07 215
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。二分查找 用于有序数组中，没有重复的数组。首先需要定义一个头（left）和尾(right)，最后通过mid和target对比不断修改头和尾指向的位置。【需要注意区间问题，根据区间的开和闭决定边界条件】推荐练习 leetcode35.
C++学习笔记：vector删除操作详解
"这篇资源是关于C++学习的笔记，主要关注`vector`(向量)容器的删除操作。文中提供了两种删除向量中元素的方法，包括`pop_back()`函数用于删除最后一个元素，以及`clear()`函数清空整个向量。此外，资料还提及了C++的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值