C++day05光速入门指南--数组和冒泡排序/选择排序

最新推荐文章于 2024-10-06 10:17:48 发布
最新推荐文章于 2024-10-06 10:17:48 发布
阅读量220 收藏
点赞数
分类专栏： 20节课光速入门C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39276337/article/details/117756296
版权

数组

练习:五只⼩猪称体重 案例描述： 在⼀个数组中记录了五只⼩猪的体重，如：int arr[5] = {300,350,200,400,250}; 找出并打印最重的⼩猪体重。

int main(){
    // 五只小猪称重 谁最重
    // 就是求数组中的最大值
    int arr[6] = {300,350,200,400,250, 200};
    int maxWeight = arr[0]; // 假设第一只猪最重
    for (int i = 0; i < sizeof(arr)/sizeof(arr[0]); ++i) {
        if (arr[i] > maxWeight)
            maxWeight = arr[i]; // 更新最重的
    }
    cout << "maxWeight = " <<maxWeight <<endl;

}

  • 数组元素逆置 案例描述：请声明⼀个5个元素的数组，并且将元素逆置. (如原数组元素为：1,3,2,5,4;逆置后输出结果为:4,5,2,3,1);
#include <iostream>
#include<cmath>
using namespace std;
int main(){
    // 交换两个变量
//    int a = 100;
//    int b = 300;
//    int temp;
//    temp = a;
//    a = b;
//    b = temp;
//    cout<< a<< endl;
//    cout<< b<< endl;
    int arr[] = {1, 3, 5, 2, 4, 29, 47, 33};
    int len = sizeof(arr)/sizeof(arr[0]);
    int temp;

    for (int i = 0; i < len/2 ;i++) {
        temp = arr[i];
        arr[i] = arr[len-1-i];
        arr[len-1-i] =temp;
    }
    for (int i = 0; i < len ;i++) {
       cout<< arr[i] << "  ";
    }


}

2

#include <iostream>
#include<cmath>
using namespace std;
int main(){

    int arr[] = {1, 3, 5, 2, 4, 29, 47, 33};
    int len = sizeof(arr)/sizeof(arr[0]);
    for(int min=0, max=len-1; min<=max;max--, min++){
        int temp = arr[min];
        arr[min] = arr[max];
        arr[max] = temp;
    }
    for (int i = 0; i < len ;i++) {
       cout<< arr[i] << "  ";
    }
}

冒泡排序

冒泡排序就是重复“从序列右边开始比较相邻两个数字的大小，再根据结果交换两个数字
的位置”这一操作的算法。在这个过程中，数字会像泡泡一样，慢慢从右往左“浮”到序列的
顶端，所以这个算法才被称为“冒泡排序”。

    1. 比较相邻元素， 如果第一个比第二个大， 就交换他们两个
    1. 对每一对相邻的元素做同样的工作， 执行完毕后， 找到第一个最大值
    1. 重复以上步骤， 每次比较 次数 - 1， 直到不需要比较









在冒泡排序中，第 1 轮需要比较 n -1 次，第 2 轮需要比较 n -2 次……第 n -1 轮需
要比较 1 次。因此，总的比较次数为 (n -1) +(n -2) +…+1 ≈ n^2
/2。这个比较次数恒定为该数值，和输入数据的排列顺序无关。
不过，交换数字的次数和输入数据的排列顺序有关。假设出现某种极端情况，如输
入数据正好以从小到大的顺序排列，那么便不需要任何交换操作；反过来，输入数据要
是以从大到小的顺序排列，那么每次比较数字后便都要进行交换。因此，冒泡排序的时
间复杂度为 O(n^2)。
一层循环/右侧开始版

#include <iostream>
using namespace std;
int main(){
    int arr[] = {5, 9, 3, 1, 2, 8, 4, 7, 6};
    int len = sizeof(arr)/sizeof(arr[0]);
    for (int j = len-1; j > 0; --j) {
        if (arr[j-1] > arr[j]){
            int temp = arr[j-1];
            arr[j-1] = arr[j];
            arr[j] = temp;
        }
    }
    for (int i = 0; i < len; ++i) {
        cout<< arr[i] << "\t";
    }
    cout<< endl;
    cout<< "================================" << endl;

    for (int j = len-1; j > 1; --j) {
        if (arr[j-1] > arr[j]){
            int temp = arr[j-1];
            arr[j-1] = arr[j];
            arr[j] = temp;
        }
    }
    for (int i = 0; i < len; ++i) {
        cout<< arr[i] << "\t";
    }
    cout<< endl;
    cout<< "================================" << endl;


    for (int j = len-1; j > 2; --j) {
        if (arr[j-1] > arr[j]){
            int temp = arr[j-1];
            arr[j-1] = arr[j];
            arr[j] = temp;
        }
    }
    for (int i = 0; i < len; ++i) {
        cout<< arr[i] << "\t";
    }
    cout<< endl;
    cout<< "================================" << endl;

    for (int j = len-1; j > 3; --j) {
        if (arr[j-1] > arr[j]){
            int temp = arr[j-1];
            arr[j-1] = arr[j];
            arr[j] = temp;
        }
    }
    for (int i = 0; i < len; ++i) {
        cout<< arr[i] << "\t";
    }
    cout<< endl;
    cout<< "================================" << endl;

    for (int j = len-1; j > 4; --j) {
        if (arr[j-1] > arr[j]){
            int temp = arr[j-1];
            arr[j-1] = arr[j];
            arr[j] = temp;
        }
    }
    for (int i = 0; i < len; ++i) {
        cout<< arr[i] << "\t";
    }
    cout<< endl;
    cout<< "================================" << endl;

    for (int j = len-1; j > 5; --j) {
        if (arr[j-1] > arr[j]){
            int temp = arr[j-1];
            arr[j-1] = arr[j];
            arr[j] = temp;
        }
    }
    for (int i = 0; i < len; ++i) {
        cout<< arr[i] << "\t";
    }
    cout<< endl;
    cout<< "================================" << endl;
    for (int j = len-1; j > 7; --j) {
        if (arr[j-1] > arr[j]){
            int temp = arr[j-1];
            arr[j-1] = arr[j];
            arr[j] = temp;
        }
    }
    for (int i = 0; i < len; ++i) {
        cout<< arr[i] << "\t";
    }
    cout<< endl;
    cout<< "================================" << endl;
}

在这里插入图片描述


#include <iostream>
using namespace std;
int main(){
    int arr[] = {5, 9, 3, 1, 2, 8, 4, 7, 6};
    int count = 0;
    int len = sizeof(arr)/sizeof(arr[0]);
    for (int i = 0; i < len -1; ++i) {
        for (int j = len-1; j > i; --j) {
            count++;
            if (arr[j-1] > arr[j]){
                int temp = arr[j-1];
                arr[j-1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    for (int i = 0; i < len; ++i) {
        cout<< arr[i] << "\t";
    }
    cout<< endl;
    cout<<  count << endl;
}

左侧开始版

#include <iostream>
using namespace std;

int main(){
    int arr[] = { 4,2,8,0,5,7,9, 1,3 };
    int len = sizeof(arr)/sizeof(arr[0]);
    // len-1-i 每次最右面的值是最大的,不用比较
    for (int i = 0; i < len-1; ++i) {
        for (int j = 0; j < len-1-i; ++j) {
            if (arr[j] > arr[j+1]){
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }

    for (int i = 0; i < len; ++i) {
        cout << arr[i]<< "\t";
    }
}

选择排序（Selection-Sort）

先把最小的拿出来
剩下的， 再把最小的拿出来
剩下的， 再把最小的拿出来
。。。
每次选择还没处理的元素里最小的元素

选择排序就是重复“从待排序的数据中寻找最小值，将其与序列最左边的数字进行交换”这一操作的算法。在序列中寻找最小值时使用的是线性查找。

比如: 对数字1~9进行排序。 使用线性查找在数据中寻找最小值，于是我们找到了最小值 1
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  • 一层版
#include <iostream>
using namespace std;
int main(){
    int arr[] = {6, 1, 7, 8, 9, 3, 5, 4, 2};
    int  len = sizeof(arr)/sizeof(arr[0]);
    int minIndex = 0;
    for (int j = 0; j < len; ++j) {
        if (arr[j] < arr[minIndex])
            minIndex = j;
    }
    cout<<"minIndex = "<< minIndex <<endl;
    // 交换
    int temp = arr[0];
    arr[0] = arr[minIndex];
    arr[minIndex] = temp;
    for (int i = 0; i < len; ++i)
        cout<<arr[i]<<"\t";
    cout<<endl;
    cout<<"-------------------------------"<<endl;
    cout<<"-------------------------------"<<endl;
    minIndex = 1;
    for (int j = 1; j < len; ++j) {
        if (arr[j] < arr[minIndex])
            minIndex = j;
    }
    cout<<"minIndex = "<< minIndex <<endl;
    // 交换
    temp = arr[1];
    arr[1] = arr[minIndex];
    arr[minIndex] = temp;
    for (int i = 0; i < len; ++i)
        cout<<arr[i]<<"\t";
    cout<<endl;
    cout<<"-------------------------------"<<endl;
    cout<<"-------------------------------"<<endl;

    minIndex = 2;
    for (int j = 2; j < len; ++j) {
        if (arr[j] < arr[minIndex])
            minIndex = j;
    }
    cout<<"minIndex = "<< minIndex <<endl;
    // 交换
    temp = arr[2];
    arr[2] = arr[minIndex];
    arr[minIndex] = temp;
    for (int i = 0; i < len; ++i)
        cout<<arr[i]<<"\t";
    cout<<endl;
    cout<<"-------------------------------"<<endl;
    cout<<"-------------------------------"<<endl;

}

在这里插入图片描述

最终版

#include <iostream>
using namespace std;

int main(){
    int arr[] = { 6, 1, 7, 8, 9, 3, 5, 4, 2};
    int len = sizeof(arr)/sizeof(arr[0]);

    for (int i = 0; i < len - 1; ++i) {
        int minIndex = i;
        for (int j = i; j < len; ++j) {
            if(arr[j] < arr[minIndex])
                minIndex = j;
        }
        // 小优化
        if (minIndex != i){
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }

    for (int i = 0; i < len; ++i) {
        cout << arr[i] <<"\t";

    }
    cout <<endl;





}

在这里插入图片描述

插入排序

在这里插入图片描述
每次处理一张牌， 把这张牌插入到前面已经排好序的牌中
插入排序是一种从序列左端开始依次对数据进行排序的算法。在排序过程中，左侧的数据陆续归位，而右侧留下的就是还未被排序的数据。插人排序的思路就是从右侧的未排序区域内取出一个数据，然后将它插人到已排序区域内合适的位置上。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include <iostream>
using namespace std;
// 冒泡排序
void insertionSort(int arr[], int len);
void printArray(int array[], int len);

int main (){
    int arr[] = {5, 9, 3, 1, 2, 8, 4, 7, 6};
    cout<< "insertionSort排序前" <<endl;
    printArray(arr, 8);
    cout<< "insertionSort排序后" <<endl;
    insertionSort(arr, 8);
    printArray(arr, 8);
    return 0;
}
void insertionSort(int arr[], int len){
//    写法1
//    for (int i = 1; i < len; i++) {
//        // 将 i 位置的值 插入到合适的位置
//        for (int j = i; j > 0; j--) {
//            if (arr[j] < arr[j-1]){
//                int temp = arr[j];
//                arr[j] = arr[j-1];
//                arr[j-1] = temp;
//            } else{
//                break; //此时就是合适的插入位置
//            }
//        }
//    }

    // 写法2
    for (int i = 1; i < len; i++) {
        // 将 i 位置的值 插入到合适的位置
        for (int j = i; j > 0 && arr[j] < arr[j-1]; j--) {
            int temp = arr[j];
            arr[j] = arr[j-1];
            arr[j-1] = temp;
        }
    }
}

void printArray(int array[], int len){
    cout<<"[";
    for (int i = 0; i < len; i++) {
        if (i == len-1)
            cout<< array[i] <<"]"<<endl;
        else
            cout<<array[i] << ", ";
    }
}
__Miracle__
关注
专栏目录
C++实现数组的排序/插入重新排序/以及逆置操作详解
12-25
插入新的数字重新排序分析：将新的数字与已经排序好的数组中的数字一一比较，直到找到插入点，然后将插入点以后的数字都向后移动一个单位（a[i+1]=a[i]），然后将数据插入即可。 代码： 代码如下:#include<iostream>...
Python-排序算法-冒泡/选择/插入排序
__Miracle__
09-07 245
冒泡排序 冒泡排序就是重复“从序列右边开始比较相邻两个数字的大小，再根据结果交换两个数字 的位置”这一操作的算法。在这个过程中，数字会像泡泡一样，慢慢从右往左“浮”到序列的 顶端，所以这个算法才被称为“冒泡排序”。 比较相邻元素， 如果第一个比第二个大， 就交换他们两个 对每一对相邻的元素做同样的工作， 执行完毕后， 找到第一个最大值 重复以上步骤， 每次比较 次数 - 1， 直到不需要比较 在冒泡排序中，第 1 轮需要比较 n -1 次，第 2 轮需要比较 n
挂号法-自定义数据数组排序.rar
03-12
这包括但不限于空数组、单个元素数组、已排序数组、逆序数组等特殊情况。 通过学习这个压缩包中的内容，开发者可以深入了解如何根据业务需求对自定义数据类型进行排序，并掌握相应的编程技巧和算法知识。在实际工作...
[C++算法入门]-冒泡排序
09-26
该资源提供了入门级别的C++算法练习，旨在帮助读者学习和理解冒泡排序算法。文档中包含了冒泡排序的基本原理和实现方法，并提供了详细的代码示例和解析。 通过学习和完成这个练习，读者将能够掌握冒泡排序算法的...
C/C++ 学习实例 - 数据结构/算法 - 排序算法的代码实例
06-05
在这个“C/C++ 学习实例”中，我们重点关注的是排序算法，这是一种处理数组或容器（如`vector`）中元素顺序的方法。排序算法的代码实例可以帮助我们更好地理解和掌握各种排序算法的原理、性能特点以及适用场景。 ...
[c语言]一句话讲清循环中break和continue的作用与区别
2303_77060768的博客
09-29 163
1.两者的作用break和contuinue都只能在循环中使用，都用来停止循环。​​​​​​​2.两者的区别break在循环中只要遇到break，就直接永久终止当前循环，开始执行当前循环之外的代码。在循环中只要遇到continue，就结束本次循环，继续进行下一次循环。
【C语言】数据类型和变量
最新发布
2302_76713442的博客
10-06 1023
一、数据类型分类（内置数据类型：字符型、整型、浮点型和布尔类型）（自定义数据类型：数组、结构体、枚举和联合体）二~三、深入研究内置数据类型（内置数据类型的大小、使用内置数据类型创建变量、signed 和 unsigned）四、自定义数据类型的内容过于庞大，所以每种自定义数据类型都专门写了一篇博客来介绍，文中有相应链接。
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
weixin_45740473的博客
10-02 963
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
C - Separated Lunch
m0_74304371的博客
10-05 262
C - Separated Lunch(KEYENCE Programming Contest 2024 (AtCoder Beginner Contest 374))
【C语言】字符函数和字符串函数(1)
hdxbufcbjuhg的博客
09-28 1719
str是\0了，循环是照常结束，但是str还要++一次，str就指向\0后面了，根据我们前面的分析就是错误的，所以这里只能把str自增的语句写在循环体内，当然，如果是拷贝字符串则不用担心这一点，可以放心把自增写在循环判断条件中。原型解析：strcpy的第一个参数是我们拷贝字符串的目的地的首地址，也就是接收拷贝的数组的首元素地址，第二个参数是我们拷贝字符串的源字符串的首地址，它的返回值就是接收拷贝的目标空间的初始地址。strcmp的作用就是帮我们比较两个字符串的大小，那么比较的依据是什么呢？
【C++】类与对象基础概念解析
A Charmer 的博客
10-03 1374
在 C++ 编程中，类与对象是核心概念之一，它们为程序设计提供了一种强大而灵活的方式来组织代码和管理数据。理解类与对象的基础概念对于掌握 C++ 编程至关重要。
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
m0_59237910的博客
10-01 411
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
【C++】STL--vector
2301_78724721的博客
10-03 816
/类模板只能实例化//初始化10个1//遍历i++)//范围for。
【C++打怪之路Lv5】-- 类和对象（下）
Sweeney_001的博客
09-29 1055
类和对象(下)：初始化列表，explicit关键字、static成员、友元、内部类、匿名对象
06.C/C++内存管理
2402_82670467的博客
09-29 1088
在这里C++的内存管理相较于C作出了许多升级，下面我们就来了解一下。我们先来看一下下面的问题，温习一下C的内存分布 在 C/C++中，内存主要分为以下几个部分： 一、栈（Stack） 1. 存储内容： - 局部变量：函数内部声明的非静态变量。 - 函数参数：传递给函数的参数。 - 函数调用信息：如返回地址等。 2. 特点： - 先进后出（LIFO）的数据结构。 - 内存由编译器自动管理，当函数被调用时分配空间，函数返回时自动释放。 - 空间相对较小，通常几兆字节。 二、堆（Heap）
C++：STL（四）之vector的基本介绍与使用方式|容器接口
白乐天_ξ( ✿＞◡❛)的博客
09-28 1220
本文主要是介绍vector容器以及接口的使用方式，和string类的那一节相似！
[C++][程序退出]详细讲解
SnowK博客
09-30 3589
[C++][程序退出]详细讲解
第九章---for循环及在STL的应用(vector\map\set\list\for_each)、嵌套while、while 统一输出、do-while
T-ang.的博客
09-29 1473
在C++中，循环语句用于重复执行一段代码，直到指定的条件不再满足。C++ 提供了几种循环机制，下面将详细讲解每种循环语句的用法和特点。
(C语言贪吃蛇)13.实现贪吃蛇四方向的移动
Botwo的博客
10-03 507
实现贪吃蛇四方向走位
C++版第4版：数据排序详解-选择排序与冒泡排序
本章主要关注选择排序和冒泡排序两种经典算法。 1. 选择排序: - 基本思想：选择排序通过多轮比较，每轮找出剩余部分中最小（或最大）的元素，将其放置到已排序序列的末尾。这个过程递归进行，直至所有元素有序。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值