《啊哈！算法》 第一章 排序

最新推荐文章于 2024-08-14 11:57:07 发布
最新推荐文章于 2024-08-14 11:57:07 发布
阅读量302 收藏 1
点赞数
文章标签： 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64238771/article/details/127390909
版权

前言

《啊哈！算法》是一本适用于小白的C语言算法书，里面的内容较为基础，这篇内容是我自学算法的记录，有些代码是个人的理解，与书上内容有所出入，内容如有错误，欢迎大家指正。

一、桶排序

5个数排序（数字在0 ~10之间）

#include <stdio.h>
int main(void)
{
    int a[11] = { 0 };    //初始化数组
    int i, j, k;
    for ( i = 0; i < 5; i++ )
    {
        scanf("%d", &k);    //输入5个数
        a[k]++;             //k每出现一次，对应的a[k]也会加1
    }
    // for ( i = 0; i < 11; i++)       //从小到大
    for ( i = 10; i >= 0; i-- )       //从大到小
    {
        for ( j = 0; j < a[i]; j++)
        {
            printf("%d ", i);        //a[i]是多少，就会打印多少次
        }
    }
    return 0;
}

初始化的数组中，数组的每一个元素都为0

若输入的数据为5，3，2，8，5

则变为a[2]=1,a[3]=1,a[5]=2,a[8]=1,其他元素仍为0    

a[0]a[1]a[2]a[3]a[4]a[5]a[6]a[7]]a[8]a[9]a[10]
00000000000
00110200100

输出则是按照数组下标进行输出

n个数排序（0~1000）（同理）

#include <stdio.h>
int main(void)
{
    int book[1001] = { 0 };    //初始化数组
    int i, j ,k, n;
    printf("Enter the total number: \n");
    scanf("%d", &n);        //输入n的值
    for ( i = 0; i < n; i++)
    {
        printf("%d: ", i + 1);
        scanf("%d", &k);
        book[k]++;
    }
    //从大到小输出数字，并且数字出现几次就输出几次
    for ( i = 1000; i >= 0; i--)
    {
        for ( j = 0; j < book[i]; j++)
        {
            printf("%d ", i);
        }
    }
    return 0;
}

 

二、冒泡排序

#include <stdio.h>
int main(void)
{
    int a[100] = { 0 };
    int i, j, t, n;
    scanf("%d", &n);    //确定输入的数字个数
    for (i = 0; i < n; i++)
    {
        scanf("%d", &a[i]);    //依次输入数字
    }
    for (i = 1; i < n; i++)   // i的大小是从1到n-1，循环n-1次
    {
        for (j = 0; j < n - i; j++) //j是从0到n-i-1，循环n-i次
        {
            if (a[j] > a[j + 1])    //如果数组元素a[j]>a[k+1],就交换两个元素的值
            {
                t = a[j];
                a[j] = a[j + 1];
                a[j + 1] = t;
            }
        }
    }
    for (i = 0; i < n; i++)        //输出数组中所有元素
    {
        printf("%d ", a[i]);
    }
    return 0;
}

示例：a[5] = {12, 35, 99, 18, 76}, 

ija[j]a[j+1]
101235
113599
129918
121899
139976
137699

 

j 的值从0~3，因为 i 的值为 1 ，j < n - i ， 即 j < 4, 此时已经可以将最大值排到最后

此时，a[5]={12,35,18,76,99}; 

 

ija[j]a[j+1]
201235
213518
211835
223576

 

 

 同理，可将第二大的值排到倒数第二个位置，依此类推，可得结果

此时，a[5] = {12, 18, 35, 76, 99},该示例的排序已经完成，但循环仍要进行，直到 j 只能为0

 


name score
#include <stdio.h>
struct student
{
    char name[20];
    int score;
};

int main(void)
{
    struct student a[100], t;   //定义a[100]和t为结构体
    int i, j, n;
    scanf("%d", &n);
    for (i = 0; i < n; i++)     
    {
        scanf("%s %d", &a[i].name, &a[i].score);
    }
    for (i = 1; i < n; i++)
    {
        for (j = 0; j < n - i; j++)        //冒泡排序
        {
            if (a[j].score < a[j + 1].score)    
            {
                t = a[j];
                a[j] = a[j + 1];
                a[j + 1] = t;
            }

        }
    }
    for (i = 0; i < n; i++)
    {
        printf("%s\n", a[i].name);        //输出以score排序后的name
    }
    return 0;
}

三、快速排序

#include <stdio.h>
int a[100], n;
void quicksort(int left, int right)
{
    int i, j, t, temp;
    if (left > right)
    {
        return;
    }
//temp中存放基准数，若基准数在右侧，左侧先动
      
    temp = a[right];//右侧(b)  

    i = left;
    j = right;
    while (i != j)
    {
        
        //从左往右(b)
        while (a[i] <= temp && i < j)
        {
            i++;
        }
        while (a[j] >= temp && i < j) 
        {
            j--;
        }

        if (i < j)    //在 i 和 j 未相遇时，交换a[i]和a[j]的值
        {
            t = a[i];
            a[i] = a[j];
            a[j] = t;
        }
    }
    //在 i 和 j 相遇时，交换基准数与相遇位置的数值
    
    a[right] = a[i];        //右侧(b)
    a[i] = temp;

    quicksort(left, i - 1);        //递归
    quicksort(i + 1, right);
}

int main(void)
{
    int i, j, t;
    scanf("%d", &n);
    for (i = 0; i< n; i++)
    {
        scanf("%d", &a[i]);
    }
    quicksort(0, n - 1);
    for (i = 0; i < n; i++)
    {
        printf("%d ", a[i]);
    }
    return 0;
}

 

a[10]={6， 1， 2， 7， 9， 3， 4， 5， 10， 8}；

设左侧移动的为i, 右侧的为j

基准数为8，i 先动，直到找到比8大的数，即a[4];

然后 j 再动，直到找到比8小的数，即a[7]

交换a[4]与a[7]的值

a[10] = {6, 1, 2, 7, 5, 3, 4, 9, 10, 8};

i 移动到a[7], 与 j 重合，

此时， 将基准数与a[7] 的值互换，

a[10] = {6, 1, 2, 7, 5, 3, 4, 8, 10, 9};

现在，基准数左侧的数都小于基准数，右侧的都大于，也就是基准数已经到了排序后自己该在的位置。

再用同样的方法分别计算基准数两侧的数组，就可以完成数组的排序。

a[0]a[1]a[2]a[3]a[4]a[5]a[6]a[7]a[8]a[9]
61279345108
61275349108
61275348109

 注意：基准数在右端时，先移动左端，是为了保证基准数可以交换到对应的位置，如上表所示，在 i 和 j 相遇时， 右侧除了，还有一个比8大的数10，将8与 i , j 相遇位置的值9交换，就可以保证8右侧有两个大于8的数字，即保证了8已经到了正确的位置

同理可得，基准数在左端时，先移动右端

#include <stdio.h>
int a[100], n;
void quicksort(int left, int right)
{
    int i, j, t, temp;
    if (left > right)
    {
        return;
    }
//temp中存放基准数，若基准数在左侧，右侧先动；在右侧，左侧先动
    temp = a[left];//左侧(a)     
    // temp = a[right];//右侧(b)  

    i = left;
    j = right;
    while (i != j)
    {
        // //从右往左(a)
        while (a[j] >= temp && i < j)       //  a[j] >= temp
        {
            j--;
        }
        while (a[i] <= temp && i < j)       //  a[i] <= temp
        {
            i++;
        }

        //从左往右(b)
        // while (a[i] <= temp && i < j)
        // {
        //     i++;
        // }
        // while (a[j] >= temp && i < j) 
        // {
        //     j--;
        // }

        if (i < j)    //在 i 和 j 未相遇时，交换a[i]和a[j]的值
        {
            t = a[i];
            a[i] = a[j];
            a[j] = t;
        }
    }
    //在 i 和 j 相遇时，交换基准数与相遇位置的数值
    a[left] = a[i];      //左侧(a)
    // a[right] = a[i];        //右侧(b)
    a[i] = temp;

    quicksort(left, i - 1);        //递归
    quicksort(i + 1, right);
}

int main(void)
{
    int i, j, t;
    scanf("%d", &n);
    for (i = 0; i< n; i++)
    {
        scanf("%d", &a[i]);
    }
    quicksort(0, n - 1);
    for (i = 0; i < n; i++)
    {
        printf("%d ", a[i]);
    }
    return 0;
}

四、排序练习

 输入一组数字，进行排序和重组

1.先排序，再去重（桶排序）

#include <stdio.h>
int main(void)
{
    int a[1001] = { 0 };    //初始化为0
    int n, i, t;

    scanf("%d",&n);

    for (i = 0; i < n; i++)
    {
        scanf("%d", &t);
        a[t] = 1;       //标记出现过的编号
    }

    for (i = 0; i < 1000; i++)
    {
        if (a[i] == 1)  //判断是否被标记
        {
            printf("%d ", i);
        }
    }
    return 0;
}

2.先去重，在排序（冒泡排序/快速排序）

#include <stdio.h>
int main(void)
{
    int a[100] = { 0 };
    int n, i, j, t;
    scanf("%d", &n);
    for (i = 0; i < n; i++)
    {
        scanf("%d", &a[i]);
    }

    for (i = 1; i < n; i++)        //冒泡排序
    {
        for (j = 0; j < n - i; j++)
        {
            if (a[j] > a[j + 1])
            {
                t = a[j];
                a[j] = a[j + 1];
                a[j + 1] = t;
            }
        }
    }

    printf("%d ", a[0]);        //先打印a[0]
    for (i = 1; i < n ; i++)    
    {
        if (a[i] != a[i - 1])  //判断从a[1]开始的代码是否与前一项的值相同
        {
            printf("%d ", a[i]);
        }
    }

    return 0;
}

//快速排序
#include <stdio.h>
int a[100], n;            
void quicksort(int left, int right)
{
    int i, j, t, temp;
    if (left > right)
    {
        return;
    }
      
    temp = a[right];

    i = left;
    j = right;
    while (i != j)
    {
        while (a[i] <= temp && i < j)
        {
            i++;
        }
        while (a[j] >= temp && i < j) 
        {
            j--;
        }
        if (i < j)   
        {
            t = a[i];
            a[i] = a[j];
            a[j] = t;
        }
    }
    
    a[right] = a[i];        
    a[i] = temp;

    quicksort(left, i - 1);        
    quicksort(i + 1, right);
}

int main(void)
{
    int i, j, t;
    scanf("%d", &n);
    for (i = 0; i< n; i++)
    {
        scanf("%d", &a[i]);
    }
    quicksort(0, n - 1);

    printf("%d ", a[0]);

    for (i = 1; i < n ; i++)
    {
        if (a[i] != a[i - 1])
        {
            printf("%d ", a[i]);
        }
    }
    return 0;
}

z28257
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
啊哈算法哈磊第八章使用并查集与快速排序实现图的最小树生成-Java实现
06-18
本资源源自《啊哈算法》第七章节的精彩内容，专注于利用并查集（Disjoint Set Union, DSU）数据结构解决实际问题，具体展示了如何通过Java实现来高效搜索犯罪团队成员。哈磊老师以其生动的讲解风格，首先深入介绍了...
[啊哈算法]数的全排列
m0_68856756的博客
04-22 1076
先来看题： 本题是一个经典的dfs问题，在n固定的情况下可以用几层循环解决问题，而题目中n不固定，所以要用搜索的方式解决问题。 全排列的问题是最经典的dfs问题，所以本题考的主要是dfs（深度优先搜索）的思维。 简单介绍一下dfs算法：一直往深处走，直到找到解或者走不下去为止，好比遇到一个分岔口，先随便选一条路走，例如选择了左边的路，无论结果如何都要返回这个岔路口，试探右边的路。这其中涉及到一个“回溯”的思想，即“回到岔路口”这一行为，所以我们需要用到函数的递归调用。 下面先来看代码： #i
《啊哈算法》第一章--排序（解析+代码）
IT OR 考公？
01-10 1321
桶排序，冒泡排序，快速排序 + 小哼买书（NOIP2006普及） 我会在原书基础上适当创新
啊哈算法之全排列问题（深度优先搜索）
qq_41907019的博客
01-30 693
废话不说，直接上代码： #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; int a[10],book[10],n;//a数组表示盒子，book数组为标记数组，n为数字个数 void dfs(int step); int main() { printf(“请输入最大数字n\n”); scanf("%d",&amp;n); dfs(1); retu...
【蓝桥杯】【啊哈！算法】深度优先搜索——全排列
MCP的博客
04-10 484
【啊哈！算法】系列文章目录 目录【啊哈！算法】系列文章目录需求介绍思路分析C语言代码总结 需求介绍 输入一个数nnn , 输出1 n1~n1 n 的全排列。 思路分析   这里我们先将这个问题形象化， 举个例子，假如有编号为1 、2、3 的3 张扑克牌和编号为1 、2、3 的3 个盒子。现在需要将这3 张扑克牌分别放到3 个盒子里面， 并且每个盒子有且只能放一张扑克牌。那么一共有多少种不同的放法呢？   好了， 现在轮到小哼出马。小哼手拿3 张扑克牌， 首先走到了1 号盒子面前。此时
啊哈算法——第一章第一节：桶排序
pythonitstream的博客
05-08 530
桶排序真快！
编程珠玑 第二版 修订版
11-01
第一部分　基础 第1章　开篇 3 1.1　一次友好的对话 3 1.2　准确的问题描述 4 1.3　程序设计 4 1.4　实现概要 5 1.5　原理 6 1.6　习题 7 1.7　深入阅读 9 第2章　啊哈! 算法 11 2.1　三个问题 11 2.2　无处不在的二...
通俗易懂的啊哈C语言1
03-29
第1章 一大波数正在靠近——排序 1 第1节 zui快zui简单的排序——桶排序 2 第2节 邻居好说话——冒泡排序 7 第3节 zui常用的排序——快速排序 12 第4节 小哼买书 20 第2章 栈、队列、链表 25 第1节 解密QQ...
编程珠玑（第2版·修订版）1
08-03
在第一部分“基础”中，作者首先通过开篇的友好对话引入了如何准确描述问题的重要性，这是程序设计的第一步。第2章“啊哈！算法”讨论了如何识别和应用常见算法，如二分搜索和排序，强调了基本操作在解决问题中的...
啊哈算法——第一章第二节：冒泡排序
pythonitstream的博客
05-14 330
冒泡排序真好！
《啊哈！算法》第一章 - 第一节 - 桶排序（简化版）Java实现
Pola_的博客
08-16 332
《啊哈！算法》第一章-第一节桶-排序（简化版）Java实现桶排序的升序排序桶排序的降序排序 这里是一个简单版的桶排序，真正的桶排序要更复杂一些，但目前足够我们用了。 题目如下： 期末考试完了老师要将同学们的分数按照从高到低排序。小哼的班上只有 5个同学，这 5个同学分别考了 5分、3分、 5分、2分和8分，考得真是惨不忍睹（满分是 10分）。接下来将分数进行从大到小排序， 排序后是 8 5 5 3 2。你有没有什么好方法编写一段程序，让计算机随机读入 5个数然后将这 5个数从大到小输出？请先想一想，至少想
《啊哈，算法》第一章、排序
qq_45467524的博客
11-13 1123
一、排序 1、桶排序(简化版) 如：对 5，3，5，2，8 进行排序 初始化：申请一个大小为10的数组 int a[10]，并将a[0]~a[10]初始化为0； for (i = 0; i <= 10; i++) { a[i] = 0; } 记录次数：进行for循环，用a[i]的值记录5，3，5，2，8这几个数出现的次数； for (i = 1; i <= 10; i++) { scanf("%d", &t)
啊哈算法的第一章——排序的笔记
ZY_yin的博客
12-21 561
啊哈算法的第一章——排序的笔记1.桶排序2.冒泡排序3.快速排序 在第一章中，作者介绍了三种排序方法： 以下是它们的实现过程： 1.桶排序 示例代码如下： // 对数据范围在0到1000之间的整数进行排序 #include<stdio.h> int main() { int book[1001], n;//book有记录、标记的意思 for (int i = 0; i <= 1000;i++) { book[i] = 0;//初始化每一个“桶”
《啊哈！算法》第1章
PoetVVV的博客
09-25 261
章节构成: 桶排序(伪) 例： 题目： 将一堆数排序，给了范围0～10，设一个数组a[11]，下标表示数，值表示该数出现几次，初始情况如图所示： 每个数出现一次，该数组值就 +1。 代码： #include<iostream> using namespace std; int main() { int a[11],i,j,t; for(i=0;i<=10;i+...
[啊哈算法] 第一章-排序
furoto_的博客
03-10 182
《啊哈算法》第一章-排序
算法的学习笔记—删除链表中重复的结点（牛客JZ76）
最新发布
业精于勤，荒于嬉
08-14 913
本文介绍了一种删除排序链表中重复节点的高效算法。通过递归的方式，算法能够有效地删除所有重复节点，并保留链表中仅出现一次的节点。此方法的实现简单且易于理解，同时在时间和空间复杂度方面表现优异，适用于处理大规模数据链表中的重复节点问题。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区。
【LeetCode每日一题】——623.在二叉树中增加一行
IronmanJay的博客
08-14 704
给定一个二叉树的根 root 和两个整数 val 和 depth ，在给定的深度 depth 处添加一个值为 val 的节点行。 注意，根节点 root 位于深度 1 。 加法规则如下: 给定整数 depth，对于深度为 depth - 1 的每个非空树节点 cur ，创建两个值为 val 的树节点作为 cur 的左子树根和右子树根。 cur 原来的左子树应该是新的左子树根的左子树。 cur 原来的右子树应该是新的右子树根的右子树。 如果 depth == 1 意味着 depth - 1 根本没有深度
代码随想录算法训练营第十一天
b1ankwall的博客
08-10 1252
参加代码随想录第43期算法训练营day11|150. 逆波兰表达式求值，239. 滑动窗口最大值，347.前 K 个高频元素，栈与队列总结
啊哈！算法：寻找缺失的32位整数
算法》这一章中，作者提到了三个小问题来引导读者思考和探索算法的力量。第一个问题是关于在一个包含最多40亿个随机排列32位整数的顺序文件中找出缺失的32位整数。这个问题可以通过理解文件中的数字范围和整数性质来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值