CS50 第五周 Data Structures

已于 2023-11-06 01:01:14 修改
阅读量88 收藏
点赞数 1
分类专栏： CS50学习笔记 文章标签： c语言
于 2023-11-04 22:26:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Anxonz/article/details/134224469
版权

先进先出 (FIFO)

  • 工作机制： 在队列中，第一个进入的元素是第一个被移除的。就像排队一样，先来的人先离开队列。
  • 操作：
    • 入队 (Enqueue): 向队列的末尾添加元素
    • 出队 (Dequeue): 从队列的前端移除元素
Enqueue(1)
Enqueue(2)
Enqueue(3)
Dequeue()  // 移除 1

先进后出 (LIFO)

  • 工作机制： 在堆栈中，最后一个进入的元素是第一个被移除的。就像一摞盘子，放在最上面的盘子是最先被拿走的。
  • 操作：
    • 入栈 (Push): 将元素压入堆栈的顶部
    • 出栈 (Pop): 从堆栈的顶部移除元素
Push(1)
Push(2)
Push(3)
Pop()  // 移除 3

list1.c

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

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

int main(void)
{
    node *list = NULL;
    // 为第一个节点分配内存
    node *n1 = malloc(sizeof(node));
    // 如果不使用动态分配内存,可以通过创建一个node结构体的实例并直接声明一个node指针
    /*
    node myNode;   // 创建一个node结构体实例
    node *list = &myNode;  // 通过指针指向该实例
    */
    if (n1 == NULL)
    {
        return 1; // 如果分配失败，返回错误码
    }

    n1->number = 1;
    n1->next = NULL;
    list = n1;

    // 为第二个节点分配内存
    node *n2 = malloc(sizeof(node));
    if (n2 == NULL)
    {
        free(n1); // 释放第一个节点的内存
        return 1;
    }

    n2->number = 2;
    n2->next = NULL;

    // 将第二个节点连接到链表
    n1->next = n2;

    // 打印链表的数据
    node *current = list; // 使用一个新的指针来遍历链表
    while (current != NULL)
    {
        printf("%d ", current->number);
        current = current->next;
    }
    printf("\n");

    // 释放链表的内存
    current = list; // 使用一个新的指针来遍历链表
    while (current != NULL)
    {
        node *temp = current;
        current = current->next;
        free(temp);
    }

    return 0;
}

list2.c

#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 number = atoi(argv[i]);

        // 分配内存以存储节点
        node *n = malloc(sizeof(node));
        if (n == NULL)
        {
            return 1; // 内存分配失败，返回错误码
        }
        
        // 初始化节点数据
        n->number = number;
        n->next = NULL;

        // 将新节点插入到链表头
        n->next = list;
        list = n;
    }

    // 遍历链表并打印节点数据
    node *ptr = list;
    while (ptr != NULL)
    {
        printf("%i ", ptr->number);
        ptr = ptr->next;
    }
    printf("\n");

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

    return 0;
}

list3.c

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

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

// 在链表末尾添加新节点
void appendNode(Node **head, int data)
{
    Node *newNode = malloc(sizeof(Node));
    if (newNode == NULL)
    {
        fprintf(stderr, "Memory allocation failed.\n");
        exit(EXIT_FAILURE);
    }

    newNode->number = data;
    newNode->next = NULL;

    if (*head == NULL)
    {
        // 如果链表为空，将新节点设置为头节点
        *head = newNode;
    }
    else
    {
        // 否则，找到链表的末尾，并将新节点连接到最后一个节点
        Node *current = *head;
        while (current->next != NULL)
        {
            current = current->next;
        }
        current->next = newNode;
    }
}

// 打印链表的数据
void printList(Node *head)
{
    Node *current = head;
    while (current != NULL)
    {
        printf("%d ", current->number);
        current = current->next;
    }
    printf("\n");
}

int main(void)
{
    Node *list = NULL; // 初始化链表为空

    // 在链表末尾添加两个节点
    appendNode(&list, 1);
    appendNode(&list, 2);
    appendNode(&list, 3);

    // 打印链表的数据
    printList(list);

    return 0;
}

trees.c

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

// 定义树节点结构
typedef struct TreeNode
{
    int data;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;

// 创建新节点
TreeNode *createNode(int data)
{
    TreeNode *newNode = (TreeNode *)malloc(sizeof(TreeNode));
    if (newNode != NULL)
    {
        newNode->data = data;
        newNode->left = NULL;
        newNode->right = NULL;
    }
    return newNode;
}

// 插入节点到二叉搜索树
TreeNode *insert(TreeNode *root, int data)
{
    if (root == NULL)
    {
        return createNode(data);
    }

    if (data < root->data)
    {
        root->left = insert(root->left, data);
    }
    else if (data > root->data)
    {
        root->right = insert(root->right, data);
    }

    return root;
}

// 中序遍历二叉树（升序排列）
void inorderTraversal(TreeNode *root)
{
    if (root != NULL)
    {
        inorderTraversal(root->left);
        printf("%d ", root->data);
        inorderTraversal(root->right);
    }
}

// 释放二叉树内存
void freeTree(TreeNode *root)
{
    if (root != NULL)
    {
        freeTree(root->left);
        freeTree(root->right);
        free(root);
    }
}

int main()
{
    // 创建根节点
    TreeNode *root = NULL;

    // 插入一些数据到二叉搜索树
    root = insert(root, 5);
    root = insert(root, 3);
    root = insert(root, 7);
    root = insert(root, 2);
    root = insert(root, 4);

    // 中序遍历并打印节点数据
    printf("Inorder Traversal: ");
    inorderTraversal(root);
    printf("\n");

    // 释放二叉树内存
    freeTree(root);

    return 0;
}

trie.c

wget https://cdn.cs50.net/2022/fall/labs/5/trie.zip

$ ls
Makefile  dog_names.txt  trie.c

./trie dog_names.txt
// 在 trie 中保存常见狗名
// https://www.dailypaws.com/dogs-puppies/dog-names/common-dog-names

#include <cs50.h>
#include <ctype.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define SIZE_OF_ALPHABET 26
#define MAXCHAR 20

// 这是一个用于实现 Trie（字典树）数据结构的结构体定义
/*
bool is_word;
这个成员表示当前节点是否代表一个完整的单词。
如果 is_word 为 true,则说明从根节点到当前节点的路径构成了一个单词
struct node *children[SIZE_OF_ALPHABET];
这个成员是一个数组,包含了所有可能的子节点
在英文字母的情况下，SIZE_OF_ALPHABET 的大小通常是 26,代表了英文字母的数量
每个数组元素都是一个指向 struct node 类型的指针,表示当前节点的子节点
这样，每个节点都能够连接到多个可能的下一个字符
这个结构体的设计用于构建 Trie 树,该树将存储一组字符串,每个字符串代表一个单词
在 Trie 树中,每个节点表示一个字符,而路径表示字符串
每个节点的 children 数组存储了当前字符后可能的下一个字符的节点.通过在树中移动,可以构建和检索存储的单词
在 is_word 标志的帮助下,我们可以知道某个节点是否代表一个完整的单词
*/

typedef struct node
{
    bool is_word;
    struct node *children[SIZE_OF_ALPHABET];
} node;


// 函数原型
bool check(char *word);
bool unload(void);
void unloader(node *current);

// trie 的根节点
node *root;

// 用于读取狗名的缓冲区
char name[MAXCHAR];

int main(int argc, char *argv[])
{
    // 检查命令行参数
    if (argc != 2)
    {
        printf("Usage: ./trie infile\n");
        return 1;
    }

    // 包含狗名的文件
    FILE *infile = fopen(argv[1], "r");
    if (!infile)
    {
        printf("Error opening file!\n");
        return 1;
    }

    // 分配 trie 的根节点
    root = malloc(sizeof(node));

    if (root == NULL)
    {
        return 1;
    }
    // 初始化根节点的成员
    //is_word 被设置为 false,因为当前还没有插入任何单词
    //children 数组被初始化为 NULL,表示根节点还没有与任何子节点相连接
    root->is_word = false;
    for (int i = 0; i < SIZE_OF_ALPHABET; i++)
    {
        root->children[i] = NULL;
    }

    // 将单词添加到 trie 中
    //通过 fscanf 逐行读取文件中的单词,然后将每个单词插入到 Trie 中
    /*
    对于每个单词,程序从根节点开始,逐个字符地遍历单词
    对于每个字符,程序计算出对应的索引 index（表示字母 'a' 到当前字符的相对位置）
    然后检查当前节点的 children 数组中是否存在对应索引的子节点
    如果不存在,就创建一个新的节点,然后移动到这个新节点
    这个过程一直持续到单词的末尾,最后将末尾节点的 is_word 设置为 true,表示这是一个完整的单词
    这样,通过这个过程,所有的单词都被成功地插入到了 Trie 树中
    */
    while (fscanf(infile, "%s", name) == 1)
    {
        node *cursor = root;

        for (int i = 0, n = strlen(name); i < n; i++)
        {
            int index = tolower(name[i]) - 'a';
            if (cursor->children[index] == NULL)
            {

                // 创建新的节点
                node *new = malloc(sizeof(node));
                new->is_word = false;
                for (int j = 0; j < SIZE_OF_ALPHABET; j++)
                {
                    new->children[j] = NULL;
                }
                cursor->children[index] = new;
            }

            // 移动到刚刚创建的节点
            cursor = cursor->children[index];
        }

        // 如果到达单词的末尾，将其标记为一个单词
        cursor->is_word = true;
    }

    if (check(get_string("检查单词：")))
    {
        printf("找到了！\n");
    }
    else
    {
        printf("未找到。\n");
    }

    if (!unload())
    {
        printf("释放内存时出现问题！\n");
        return 1;
    }

    fclose(infile);
}

// TODO: 完成 check 函数，如果找到返回 true，未找到返回 false
bool check(char *word)
{
    // 从 trie 的根节点开始
    node *cursor = root;

    // 遍历输入单词的每个字符
    for (int i = 0, n = strlen(word); i < n; i++)
    {
        // 计算字符对应的索引
        int index = tolower(word[i]) - 'a';

        // 如果当前节点的子节点为 NULL，说明单词不存在
        if (cursor->children[index] == NULL)
        {
            return false;
        }

        // 移动到下一个节点
        cursor = cursor->children[index];
    }

    // 到达单词的末尾，检查是否标记为一个单词
    return cursor->is_word;
}

// 释放 trie 占用的内存
bool unload(void)
{
    // 递归函数处理所有的释放
    unloader(root);

    return true;
}

void unloader(node *current)
{
    // 遍历所有的子节点，查看它们是否指向了某个地方，如果是则移动到那里
    for (int i = 0; i < SIZE_OF_ALPHABET; i++)
    {
        if (current->children[i] != NULL)
        {
            unloader(current->children[i]);
        }
    }

    // 在检查所有的子节点都指向空之后，可以释放节点，并返回到这个函数的前一次迭代。
    free(current);
}

inheritance.c

一个人的血型由两个等位基因（即基因的不同形式）决定。三种可能的等位基因是 A、B 和 O，每个人都有两个（可能相同，也可能不同）。每个孩子的父母会随机地将自己的两个血型等位基因之一传递给他们的孩子。因此，可能的血型组合有：OO、OA、OB、AO、AA、AB、BO、BA 和 BB。

例如，如果一个父亲的血型是AO，另一个父亲的血型是BB，那么孩子的可能血型将是AB和OB，具体取决于从每个父亲那里接收了哪个等位基因。同样，如果一个父亲的血型是AO，另一个父亲的血型是OB，那么孩子的可能血型将是AO、OB、AB 和 OO。

wget https://cdn.cs50.net/2022/fall/labs/5/inheritance.zip

$ ls
Makefile  inheritance.c

$ ./inheritance
// 模拟血型的遗传传承

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

// 每个人有两位父母和两个等位基因
typedef struct person
{
    struct person *parents[2];
    char alleles[2];
} person;

const int GENERATIONS = 3;
const int INDENT_LENGTH = 4;

// 创建一个新的家庭，包括 `generations` 代人
person *create_family(int generations);
void print_family(person *p, int generation);
void free_family(person *p);
char random_allele();

int main(void)
{
    // 种子随机数生成器
    srand(time(0));

    // 创建一个有三代人的新家庭
    person *p = create_family(GENERATIONS);

    // 打印血型家谱
    print_family(p, 0);

    // 释放内存
    free_family(p);
}

// 创建一个具有 `generations` 代的新个体
person *create_family(int generations)
{
    // TODO: 为新个体分配内存
    person *new_person = malloc(sizeof(person));
    // 如果仍有待创建的代数
    if (generations > 1)
    {
        // 通过递归调用 create_family 创建当前个体的两位新父母
        person *parent0 = create_family(generations - 1);
        person *parent1 = create_family(generations - 1);

        // TODO: 为当前个体设置父母指针
        new_person->parents[0] = parent0;
        new_person->parents[1] = parent1;
        // TODO: 根据父母的等位基因，随机分配当前个体的等位基因
        new_person->alleles[0] = random_allele();
        new_person->alleles[1] = random_allele();
    }

    // 如果没有代数需要创建
    else
    {
        // TODO: 设置父母指针为 NULL
        new_person->parents[0] = NULL;
        new_person->parents[1] = NULL;

        // TODO: 随机分配等位基因
        new_person->alleles[0] = random_allele();
        new_person->alleles[1] = random_allele();
    }

    // TODO: 返回新创建的个体
    return new_person;
}

// 释放 `p` 及其所有祖先的内存。
void free_family(person *p)
{
    // 处理基本情况
    if (p == NULL)
    {
        return;
    }

    // 递归释放父母
    free_family(p->parents[0]);
    free_family(p->parents[1]);

    // 释放子代
    free(p);
}

// 打印每个家庭成员及其等位基因。
void print_family(person *p, int generation)
{
    // 处理基本情况
    if (p == NULL)
    {
        return;
    }

    // 打印缩进
    for (int i = 0; i < generation * INDENT_LENGTH; i++)
    {
        printf(" ");
    }

    // 打印个体
    if (generation == 0)
    {
        printf("子代（第 %i 代）：血型 %c%c\n", generation, p->alleles[0], p->alleles[1]);
    }
    else if (generation == 1)
    {
        printf("父母（第 %i 代）：血型 %c%c\n", generation, p->alleles[0], p->alleles[1]);
    }
    else
    {
        for (int i = 0; i < generation - 2; i++)
        {
            printf("曾");
        }
        printf("祖父母（第 %i 代）：血型 %c%c\n", generation, p->alleles[0], p->alleles[1]);
    }

    // 打印当前代的父母
    print_family(p->parents[0], generation + 1);
    print_family(p->parents[1], generation + 1);
}

// 随机选择一个血型等位基因。
char random_allele()
{
    int r = rand() % 3;
    if (r == 0)
    {
        return 'A';
    }
    else if (r == 1)
    {
        return 'B';
    }
    else
    {
        return 'O';
    }
}

Anxonz
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
二叉树的递归版实现
qq_40736410的博客
05-20 163
tree.h#pragma once#include&lt;stdlib.h&gt;#include&lt;stddef.h&gt;#include&lt;string.h&gt;#define TEST_HEAND printf("========%s=========\n",__FUNCTION__);typedef  char TreeNodeType;typedef  char SeqQu...
二叉树的基本操作
Cecilia3333的博客
05-04 251
创建树节点TreeNode* CreateTreeNode(TreeNodeType value){ TreeNode* new_node = (TreeNode*)malloc(sizeof(TreeNode)); new_node-&gt;data = value; new_node-&gt;lchild = NULL; new_node-&gt;rchild ...
哈佛大学cs50课程笔记_哈佛CS50指南：如何为您选择正确的课程（带有免费证书）
cumian8165的博客
08-21 7894
哈佛大学cs50课程笔记In January, I wrote an article on Class Central about CS50, Harvard’s Introduction to Computer Science, which offers a free certificate. In this article, I'll go over CS50’s entire 10-cour...
计算机科学cs50_世界顶尖CS大学提供500门免费计算机科学课程
08-18 703
计算机科学cs50Every year, Class Central publishes rankings of the world’s highest rated and most popular online courses. 每年，Class Central都会发布世界上评分最高和最受欢迎的在线课程的排名。 These rankings are based on user ratings ...
CS50X week5 笔记
aleyzi的博客
01-26 669
场景：当用户在使用语音唤醒语音助手时，会出现无法唤醒的情况，为了解决这一情况，需要选择怎样的数据结构？但是这样的数据结构会占用更多的内存，即使有些索引后面没有内容，但还是需要占用内存存放该索引。但是这样会占用大量的内存，并且工程师需要花更多的时间去构造这个复杂的数据结构。，可以直接插入到最前面；创建数据类型为 node 的变量，这时里面都是垃圾数据。对 n 里面的变量 number 赋值。对 n 里面的变量 number 赋值。对 n 里面的变量 next 赋值。对 n 里面的变量 next 赋值。
计算机编程课程顺序_您可以在八月开始的500项免费在线编程和计算机科学课程
cumi6497的博客
07-26 689
计算机编程java课程Six years ago, universities like MIT and Stanford first opened up free online courses to the public. Today, more than 800 schools around the world have created thousands of free online cour...
程序员应该访问的最佳网站中文版
天道酬勤
09-09 1056
程序员应该访问的最佳网站中文版原版 原文链接 :https://github.com/tuteng/Best-websites-a-programmer-should-visit-zh/blob/master/README.md 一些对程序员有用的网站 在学习CS的时候有一些你必须知道的有用的站点来获取通知为了你的技术储备和学习新知识。这里是一个你应该访问的不是非常全面的一些站点的列表，这个...
程序员应该访问的最佳网站中文版原版
女王の专属领地
02-06 1543
  程序员应该访问的最佳网站中文版原版   一些对程序员有用的网站 在学习CS的时候有一些你必须知道的有用的站点来获取通知为了你的技术储备和学习新知识。这里是一个你应该访问的不是非常全面的一些站点的列表，这个列表会不断更新，只要我能得到链接，你也可以通过添加你知道的来为此做出贡献 Index 索引 当你遇到问题时 新闻篇 针对新手的代码训练 针对那些想开始一个小的项目但是无从下...
CS相关经典书籍的书评
MyShowTime的专栏
12-07 8824
CS相关书籍的书评[转载]Revisit Computer Science via reading books【动机】就计算机这个专业来说吧，因为我是非科班出身的学生，要重新开始补相应的知识，目前定下来要学习的基础理论知识有：离散数学，数据结构与算法，组成原理，汇编，操作系统，网络等等，有的时候觉得这里每一个知识点要学的深入的话都是无底洞，不过我又是那种喜欢追根究底
-CS50x-Week7:CS50x第7周的习题集
04-22
5. **模块与导入**：Python有丰富的标准库和第三方库。通过`import`语句，我们可以引入这些模块，利用它们的功能。例如，`math`模块提供了数学运算，`os`模块则与操作系统交互。 6. **异常处理**：使用`try-except`...
CS50：:graduation_cap:哈佛CS50x — 2018解决方案:man:
02-05
CS50x — 2018解决方案。 尽管这些解决方案将帮助您轻松完成本课程，但在查看我的任何解决方案之前，您应尽力找出一个可行的解决方案。 我认为，投入时间和精力来解决问题会让自己陷入困境，这是最终精通的唯一方法...
cs50-birthdays:CS50 2021第9周实验9
05-26
CS50第9周实验9 完成Web应用程序的实现，以使用户能够存储和跟踪生日。 当通过GET请求/路由时，您的Web应用程序应在表格中显示数据库中的所有人员以及他们的生日。 首先，在application.py中，在GET请求处理中...
CS50
02-20
CS50是哈佛大学提供的一门广受欢迎的计算机科学入门课程，旨在教授学生计算机科学的基础概念和技术。这门课程不仅涵盖了编程语言C的基础知识，还包括数据结构、算法、网络、数据库、人工智能等多个重要领域。2019年...
贸易常见付款方式D/P，D/A，T/T，L/C
王小磊
07-23 532
D/P付款交单代收行必须在进口商付清货款后，才可将商业单据交给进口方D/ADocumentsagainstAcceptance承兑交单出口人的交单以进口人在汇票上承兑为条件，一般承兑时会注明具体付款的日期T/T电汇汇出行应汇款人申请，拍发加押电报给在另一国家的分行或代理行（即汇入行），指示解付一定金额给收款人L/C信用证银行根据进口人（买方）的请求，开给出口人（卖方）的一种保证承担支付货款责任的书面凭证。
b050闲置图书分享-springboot+vue+elementui.zip（可运行源码+sql文件+文档）
07-23
本次开发的闲置图书分享平台实现了收货地址管理、字典管理、公告管理、留言板管理、图书管理、图书收藏管理、图书评价管理、图书订单管理、用户管理、管理员管理等功能。系统用到了关系型数据库中王者MySql作为系统的数据库，有效的对数据进行安全的存储，有效的备份，对数据可靠性方面得到了保证。并且程序也具备程序需求的所有功能，使得操作性还是安全性都大大提高，让闲置图书分享平台更能从理念走到现实，确确实实的让人们提升信息处理效率。 管理图书的数据，此页面主要实现图书的增加、修改、删除、查看的功能。公告信息管理页面提供的功能操作有：新增公告，修改公告，删除公告操作。公告类型管理页面显示所有公告类型，在此页面既可以让管理员添加新的公告信息类型，也能对已有的公告类型信息执行编辑更新，失效的公告类型信息也能让管理员快速删除。
《大学生职业生涯规划与就业指导》大一阶段课程作业
最新发布
07-24
《大学生职业生涯规划与就业指导》大一阶段课程作业
开题报告潮汕特产直销系统 已通过开题答辩的.doc
07-23
随着互联网的高速发展，人们的生活方式发生了翻天覆地的变化，在过去，人们想要购买很远地方的东西会非常麻烦，因为是通信和交通都不是十分的方便，而现在网络购物成为了人们日常生活中不可或缺的一部分。在这样的背景下，互联网与传统行业的融合已经成为了一种不可阻挡的趋势。对于中国特色的潮汕特产来说，这一趋势也带来了巨大的变革和发展机遇[1]。
Python性能优化：掌握性能分析工具的实战指南
07-23
Python是一种广泛使用的高级编程语言，由Guido van Rossum于1989年底发明，第一个公开发行版发行于1991年。Python的设计哲学强调代码的可读性和简洁的语法（尤其是使用空格缩进来区分代码块，而不是使用大括号或关键词）。这使得Python被认为是一种易于学习的语言，同时具备强大的功能，适合初学者和经验丰富的程序员。 Python的主要特点包括： 1. **易于学习**：Python有相对较少的关键字，结构简单，和一个明确定义的语法。 2. **易于阅读**：Python代码定义的清晰度使得它像可执行伪代码。 3. **易于维护**：Python的成功在于它的源代码是相当容易维护的。 4. **广泛的标准库**：Python的标凑库很庞大，包含用于互联网通信、网络通信、数据压缩、加密、系统管理等的模块。 5. **跨平台**：Python可以在多种操作系统上运行，包括但不限于Windows、Mac OS X、Linux等。 6. **解释型语言**：Python是一种解释型语言，这意味着开发过程中没有编译步骤。 7. **动态类型系统**：Python不会在编写
国外有什么比较好的计算机课程
05-20
以下是一些国外比较好的计算机课程： 1. CS50 - Introduction to Computer Science, Harvard University 2. MIT OpenCourseWare - Computer Science and Programming 3. Stanford University - Introduction to Computer Science 4. Coursera - Algorithms, Princeton University 5. Udacity - Introduction to Artificial Intelligence, Georgia Tech 6. edX - Introduction to Python Programming, Microsoft 7. Carnegie Mellon University - Introduction to Computer Science 8. California Institute of Technology - Introduction to Computer Science 9. University of California, Berkeley - Introduction to Data Science 10. University of Washington - Computer Science and Engineering 这些课程覆盖了计算机科学的各个方面，包括编程、算法、人工智能、数据科学等等。它们都是由顶尖大学或知名公司提供的高质量课程，可以帮助你更好地了解计算机科学的知识和技能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Anxonz

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值