CS50X week5 笔记

最新推荐文章于 2024-11-12 20:01:17 发布
最新推荐文章于 2024-11-12 20:01:17 发布
阅读量713 收藏 14
点赞数 13
分类专栏： cs50 文章标签： 笔记 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aleyzi/article/details/135872935
版权

week 5 Data Structurs

The trade-offs between different data structures

场景：当用户在使用语音唤醒语音助手时，会出现无法唤醒的情况，为了解决这一情况，需要选择怎样的数据结构？

需要考虑以下几个方面的问题：

  • 快速删除
  • 快速插入
  • 快速搜索

首先看链表：

对于链表来说，插入数据是最快的，可以直接插入到最前面；但是链表在搜索和删除的速度较慢

image-20240122210030113

哈希表：

搜索和插入速度最快，这里用到了索引的概念；但是这样的数据结构会占用更多的内存，即使有些索引后面没有内容，但还是需要占用内存存放该索引

image-20240122210333587

Trie：

搜索和插入速度最快；但是这样会占用大量的内存，并且工程师需要花更多的时间去构造这个复杂的数据结构

image-20240122210823943

Node

通过观察上面的数据结构，发现它们都有一个称为节点的共同特征，节点的模板可以用下面代码表示：

typedef struct node
{
    string phrase;
    struct node *next; // 这是一个指向结构体的指针
}
node;
Stacks and Queues

FIFO (first in first out)：queue，先进先出

LIFO (last in first out)：stacks，后进先出

typedef struct
{
    person people[CAPACITY];
    int size;
}
stack
// 这里 CAPACITY 和 size 之间有什么区别？
// CAPACITY 表示总共能存多少
// size 表示当前的量是多少
Resizing Arrays

1703836488977

创建一个数组（不推荐这种方式，只是用于课堂演示）：

#include <stdio.h>

int main(void)
{
    int list[3];
    
    list[0] = 1;
    list[1] = 2;
    list[2] = 3;
    
    for (int i = 0; i < 3; i++)
    {
        printf("%i\n", list[i]);
    }
}

通过指针和分配内存的方式，优化代码（不推荐这种方式，只是用于课堂演示）：

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int *list = malloc( 3 * sizeof(int));
    // 这里判断是否还有多的内存，有的话才能继续后面的程序
    if (list == NULL)
    {
        return 1;
    }
    
    list[0] = 1;
    list[1] = 2;
    list[2] = 3;
    
    // 将这个数组增加一位
    int *tmp = malloc( 4 * sizeof(int));
    if (tmp == NULL)
    {
        // 如果没有内存，tmp 没有分配成功，就将之前分配的释放，然后结束程序
        free(list);
        return 1;
    }
    
    // 复制
    for (int i = 0; i < 3; i++)
    {
        tmp[i] == list[i];
    }
    tmp[3] = 4;
    
    // 将 list 原来 3 个数组的内存空间释放
    free(list);
    
    // Remember list of size 4
    list = tmp;
    
    for (int i = 0; i < 4; i++)
    {
        printf("%i\n", list[i]);
    }
    
    // 释放，这里释放 list tmp 均可，因为两个指向的同一个内存空间
    // 写程序释放非临时变量更好
    free(list);
    return 0;
}

Modify your code as follows:

C comes with a very useful function called realloc that will reallocate the memory for you. realloc takes two arguments. First, it asks you to specify the array you are attempting to copy. Second, it asks you to specify the size to which you would like the final array to be.

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int *list = malloc( 3 * sizeof(int));
    // 这里判断是否还有多的内存，有的话才能继续后面的程序
    if (list == NULL)
    {
        return 1;
    }
    
    list[0] = 1;
    list[1] = 2;
    list[2] = 3;
    
    // 将这个数组增加一位
    int *tmp = realloc(list, 4 * sizeof(int));
    if (tmp == NULL)
    {
        // 如果没有内存，tmp 没有分配成功，就将之前分配的释放，然后结束程序
        free(list);
        return 1;
    }
    
    list = tmp;
    list[3] = 4;
    
    for (int i = 0; i < 4; i++)
    {
        printf("%i\n", list[i]);
    }
    
    // 释放，这里释放 list tmp 均可，因为两个指向的同一个内存空间
    // 写程序释放非临时变量更好
    free(list);
    return 0;
}

int *tmp = realloc(list, 4 * sizeof(int));
// 这里为什么要重新分配赋值给一个新的变量，而不是直接写成 realloc(list, 4 * sizeof(int))
// 直接写会将改变直接作用到 list 上，这时我们并不确定这个一定是成功的，要是不成功，list 原来指向的内存里的值都直接被 NULL 覆盖了，所以需要有一个变量来接收返回值，确认分配成功后再进行更新

Notice that int *tmp = realloc(list, 4 * sizeof(int)) creates a list of size four integers. Then, it copies the values of list to this new array. Finally, a pointer called tmp points to the location of memory of this new array. The copying is handled by realloc. Once that copy is made, the memory at the location of list is freed. Then, the pointer called list is pointed at the location of tmp, where the new array is located.

Linked Listed

1704454185716

节点用代码表示：

typedef struct node
{
    int number;
    struct node *next;
}
node;

链表的缺陷：

  • 使用了两倍的内存
  • 由于其是不连续的，所以无法进行索引
  • 性能降低：无法使用二分搜索，因为两个数据之间可能会有不同数量的内存数据

创建链表的过程：

  1. 创建数据类型为 node 的变量，这时里面都是垃圾数据

    1704455586287

  2. 创建一个临时变量

    1704455624010

  3. 对 n 里面的变量 number 赋值

    1704455671673

  4. 对 n 里面的变量 next 赋值

    1704455705936

  5. 将 list 指向临时变量 n 的位置

    1704455759144

  6. 再创建一个临时变量

    1704455795682

  7. 对 n 里面的变量 number 赋值

    1704456002810

  8. 对 n 里面的变量 next 赋值

    1704456057299

  9. n.next 指向和 list 一样的内存地址

    1704456047834

  10. 将 list 指向临时变量 n 的位置

    1704456037365

通过代码实现上述功能：

#include <stdio.h>
#include <stdlib.h>

// 链表节点的数据构造
typedef struct node
{
    int number;
    struct node *next;
}
node;

int main(int argc, char *argv[])
{
    // 创建初始链表
    node *list = NULL;

    // 通过输入参数进行循环，第 0 个数据是运行文件名
    for (int i = 1; i < argc; i++)
    {
        int number = atoi(argv[i]);

        node *n = malloc(sizeof(node));

        if (n == NULL)
        {
            return 1;
        }

        n->number = number;
        n->next = list;
        list = n;
    }

    // 打印
    node *ptr = list;
    while (ptr != NULL)
    {
        printf("%i\n", ptr->number);
        ptr = ptr->next;
    }

    // 另一种写法
    //for (node *ptr = list; ptr != NULL; ptr = ptr->next)

    // 释放内存
    ptr = list;
    while (ptr != NULL)
    {
        // 这里要先把指向下一个数据的指针记录下来，不然释放内存后就没有了
        node *next = ptr->next;
        free(ptr);
        ptr = next;
    }
}

list_append:

// 往后添加元素
#include <stdio.h>
#include <stdlib.h>

typedef struct node
{
    int number;
    struct node *next;
}
node;

int main(int argc, char *argv[])
{
    node *list = NULL;

    // 对每个输入的数据进行处理
    for (int i = 1; i < argc; i++)
    {
        // 将输入的数字转换成 Int 类型并保存下来
        int num = atoi(argv[i]);

        // 将输入的数据保存
        node *n = malloc(sizeof(node));
        if (n == NULL)
        {
            return 1;
        }
        n->number = num;
        n->next = NULL;

        // 如果本来就是空列表，则直接添加即可
        if (list == NULL)
        {
            list = n;
        }

        // 若不是空列表，则找到末尾再添加
        else
        {
            for (node *ptr=list; ptr != NULL; ptr = ptr->next)
            {
                if (ptr->next == NULL)
                {
                    ptr->next = n;
                    // 这里找到以后必须要跳出
                    // 不然，这时后面已经添加了一个，经过ptr = ptr->next又指向最后一个，会进行无限添加
                    break;
                }
            }
        }
    }

    // 打印
    for (node *ptr=list; ptr != NULL; ptr = ptr->next)
    {
        printf("%i\n", ptr->number);
    }

    // 释放内存
    node *ptr = list;
    while (ptr != NULL)
    {
        node *next = ptr->next;
        free(ptr);
        ptr = next;
    }
}

list-sort:

// 按元素的大小放置到相应的位置
#include <stdio.h>
#include <stdlib.h>

typedef struct node
{
    int number;
    struct node *next;
}
node;

int main(int argc, char *argv[])
{
    node *list = NULL;

    // 对每个输入的数据进行处理
    for (int i = 1; i < argc; i++)
    {
        // 将输入的数字转换成 Int 类型并保存下来
        int num = atoi(argv[i]);

        // 将输入的数据保存
        node *n = malloc(sizeof(node));
        if (n == NULL)
        {
            return 1;
        }
        n->number = num;
        n->next = NULL;

        // 如果本来就是空列表，则直接添加即可
        if (list == NULL)
        {
            list = n;
        }

        // 如果添加的数字是最小的
        else if (n->number < list->number)
        {
            n->next = list;
            list = n;
        }

        // 如果添加的数字大小不是最小的
        else
        {
            for (node *ptr = list; ptr != NULL; ptr = ptr->next)
            {
                // 最大的那个
                if (ptr->next == NULL)
                {
                    ptr->next = n;
                    break;
                }

                // 在中间
                if (n->number < ptr->next->number)
                {
                    n->next = ptr->next;
                    ptr->next = n;

                    // 要插入的元素找到了相应的位置就不需要再继续循环下去了
                    break;
                }
            }

        }
    }

    // 打印
    for (node *ptr=list; ptr != NULL; ptr = ptr->next)
    {
        printf("%i\n", ptr->number);
    }

    // 释放内存
    node *ptr = list;
    while (ptr != NULL)
    {
        node *next = ptr->next;
        free(ptr);
        ptr = next;
    }
}

list-free：

#include <stdio.h>
#include <stdlib.h>

// 链表节点的数据构造
typedef struct node
{
    int number;
    struct node *next;
}
node;

void free_list(node *list);

int main(int argc, char *argv[])
{
    // 创建初始链表
    node *list = NULL;

    // 通过输入参数进行循环，第 0 个数据是运行文件名
    for (int i = 1; i < argc; i++)
    {
        int number = atoi(argv[i]);

        node *n = malloc(sizeof(node));

        if (n == NULL)
        {
            free_list(list);
            return 1;
        }

        n->number = number;
        n->next = list;
        list = n;
    }

    // 打印
    node *ptr = list;
    while (ptr != NULL)
    {
        printf("%i\n", ptr->number);
        ptr = ptr->next;
    }

    // 另一种写法
    //for (node *ptr = list; ptr != NULL; ptr = ptr->next)

    // 释放内存
    free_list(list);
}

void free_list(node *list)
{
    while (list != NULL)
    {
        node *next = list->next;
        free(list);
        list = next;
    }
}
Trees

二叉搜索数：Binary search trees

实现的代码如下：

// 创建一个二叉树

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef struct node
{
    int number;
    struct node *left;
    struct node *right;
}
node;

void free_tree(node *root);
void print_tree(node *root);
int search_tree(node *tree, int num);

int main(void)
{
    // 创建里面没有任何数据的数
    node *tree = NULL;

    // 添加第一个数
    node *n = malloc(sizeof(node));
    if (n == NULL)
    {
        return 1;
    }
    n->number = 2;
    n->left = NULL;
    n->right = NULL;
    tree = n;

    // 添加左边第一个数
    n = malloc(sizeof(node));
    if (n == NULL)
    {
        // 这里不能直接返回，需要把之前用到的所有空间都释放才行
        // 写一个专门释放空间的函数
        free_tree(tree);
        return 1;
    }
    n->number = 1;
    n->left = NULL;
    n->right = NULL;
    tree->left = n;

    // 同理，添加右边第一个数
    n = malloc(sizeof(node));
    if (n == NULL)
    {
        // 这里不能直接返回，需要把之前用到的所有空间都释放才行
        // 写一个专门释放空间的函数
        free_tree(tree);
        return 1;
    }
    n->number = 3;
    n->left = NULL;
    n->right = NULL;
    tree->right = n;

    // 打印函数
    print_tree(tree);

    // 搜索该二叉树，暂不支持搜索不存在的
    int search_num;
    printf("search_num: ");
    scanf("%i", &search_num);
    int result = search_tree(tree, search_num);
    printf("%i\n", result);

    // 释放内存函数
    free_tree(tree);

    return 0;
}

void free_tree(node *root)
{
    if (root == NULL)
    {
        return;
    }

    free_tree(root->left);
    free_tree(root->right);
    // 这里是 free 函数，不需要再递归了
    free(root);
}

void print_tree(node *root)
{
    if (root == NULL)
    {
        return;
    }

    print_tree(root->left);
    // 这里只需要打印一次，因为每个树的根节点只有一个
    printf("%i\n", root->number); 
    print_tree(root->right);
}

// 搜索该二叉树
int search_tree(node *tree, int num)
{
    if (tree == NULL)
    {
        return 1;
    }

    else if (num < tree->number)
    {
        return search_tree(tree->left, num);
    }

    else if (num > tree->number)
    {
        return search_tree(tree->right, num);
    }

    else if (num == tree->number)
    {
        return 0;
    }
}
aleyzi
关注
专栏目录
CS50 2016 Week 8 学习笔记
丰伟磊的博客
09-11 495
python； 函数、变量、循环、if语句、运行python程序、基本数据类型； 类和面向对象编程； MVC模式；Web server；flask框架。
CS50 2016 Week9 学习笔记
丰伟磊的博客
09-12 841
数据库管理系统；SQL语言；关系型数据库MySQL；
CS50X week3 学习笔记
aleyzi的博客
04-20 639
CS50X week3 学习笔记
CS50X week4 学习笔记
aleyzi的博客
04-20 564
CS50X WEEK4 学习笔记
CS50 week0 笔记
Remember23357的博客
12-10 923
2.为什么看0/1表达的文件比单纯的hello world表达的0与1数量更多？--不仅仅是字母，还有打印等作用。为什么视频和音乐有很多格式：我们采用数字表达很多东西然后进行标准化，但是不同的人意见不同，所以有很多格式。思维：进行抽象，简化某件事，不关注低级而关注高级后者过程本身，也就是更高层次进行思考的操作。我们平时不会用0和1，会选择更高级的语言来表达【符合上文提到的思想：抽象】不断优化，用最简单的方法表现出来【当然内部的逻辑是自己背后定好的】参数--------函数--------副作用（此处）
CS50x 2022 笔记
furoto_的博客
06-16 620
CS50X学习笔记
CS50 week1 笔记
Remember23357的博客
12-12 1001
操作步骤：创建文件（code A.c)--编写代码---编译机器代码(make A.c)--运行代码(./A)source code（源代码）---->>compiler(编译器)---->machine code（机器代码）(2)使用键盘的向后键滚动，按一下向上键看到写的最后一个命令，按两下是写的倒数第二个命令。double使用双倍的位数，用64代替float的32位,用来提高精度。一个是我作为人类写的代码文件，一个是编译器将我的源代码翻译成机器代码。(1)不能用=，=的意思是从右到左的赋值；
CS50P week0 学习笔记 - 更新完成
aleyzi的博客
01-27 788
cs50p week0 学习笔记
CS50X笔记(第一讲)
weixin_60789461的博客
01-07 829
第一讲： 1.计算机科学是啥 输入==>黑箱（代码）[为了解决问题]==>输出 2.数字及二进制 3.字符串，文本（ASCII）码[72,73,33]==[HI!] 4.一个表情包，其实是很多个小方块，放大可以看的很清楚 example： face with tears of joy（笑哭） 000000011111011000000010 5.很多颜色都是由二进制来表示的 （1）图片就是由成千上万的点，正方形（由二进制形成的）形成 （2）视频是由很多张图片所构成的
【CS50】 week1 笔记
weixin_44630689的博客
07-25 82
double, a floating-point value with more digits than a float 【拥有更多数字的浮点数】float, a floating-point value, or real number with a decimal value【浮点数】source code（源代码）---->>compiler(编译器)---->machine code（机器代码）操作步骤：创建文件（code A.c)–编写代码—编译机器代码(make A.c)–运行代码(./A)
CS50P week2 学习笔记
aleyzi的博客
02-10 386
上面三种方法看似第一种方法是最简单的，但第三种方法可以帮助解决更复杂的问题。这个代码正确，但是有个缺陷：如果需要计数到很大，会十分麻烦。中 student 是键，所以整体是查找键对应的值。结果是仅打印键的值，如果想同时打印键和相应的值呢？同时，还有一个 Python 的关键词。这样的写法是更简洁，但可读性变差。更多关于列表的内容到官网进行查看。需要注意，这里代表没有值的意思。
cs50web:webdev week.1
03-29
【cs50web:webdev week.1】是哈佛大学CS50课程的网络开发部分第一周的内容，主要聚焦在Web开发的基础知识上，特别是与Python语言相关的技术。这一周的学习旨在为初学者构建一个坚实的Web开发基础，涵盖了一系列关键...
CS50 2016-Week 0 学习笔记
丰伟磊的博客
09-05 1287
机器语言（二进制数）； C语言； Python（解释型语言）
Greiner 经典力学（多体系统和哈密顿力学）第十二章 学习笔记（Rotation About a Point）
Ivan 的专栏
11-09 1157
上一章是绕定轴转动，这章是绕定点转动。这一章明显上难度了。
Window.history API学习笔记
常备不懈
11-12 513
在现代前端开发中，单页应用（SPA）的流行让我们对于页面的浏览历史管理需求愈加明显。`window.history` API作为浏览器提供的原生API，能够帮助开发者更加细致地控制用户的导航体验。本文将介绍`window.history` API的几个常见方法，并探讨它们的使用场景。
JavaScript面向对象笔记(4)
maoshunsheng的博客
11-10 1027
<script>//小括号表示优先级var reg = /^(abc){3}$/ // 表示abc重复3次</script>
软考中级 软件设计师 上午考试内容笔记（个人向）Part.1
ozawacai的博客
11-09 998
如标题所示
Spring学习笔记_32——事务TransactionStatus接口
LuckyLay的博客
11-12 279
TransactionStatus是Spring框架中用于表示事务状态的一个关键接口。它提供了一系列方法来查询和控制事务的执行状态，对于编程式事务管理尤为重要。TransactionStatus接口主要用来存储事务执行的状态，并且接口中定义了一组方法，用来判断或者读取事务的状态信息，
QT开发笔记之小知识
最新发布
ZaiLuShang2121的博客
11-12 283
QT学习笔记 小知识点
哈佛CS50x课程2021版拉美地区翻译发布
资源摘要信息:"哈佛大学CS50x课程是全球知名的计算机科学入门课程，cs50x-2021-latam是该课程在2021年的版本，并针对拉丁美洲地区进行了本地化翻译，使其更适合以西班牙语为母语的学习者。该课程覆盖了广泛的主题，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值