为了账号安全，请及时绑定邮箱和手机立即绑定

作业社区

探索学习新天地，共享知识资源！

0份 提交作业
0个 布置作业
0份 满分作业
得分 100
学习任务

qq_康斯坦丁_0 的学生作业：

内存空间： 一个进程中多个线程共享同一个内存空间 多个进程拥有独立的内存空间 进程/线程间通讯： 线程间通讯方式简单 进程间通讯方式复杂

+11
来源：物联网/嵌入式全能工程师（提薪优选） · 线程的概念-课后练习
得分 100
学习任务

慕后端3277080 的学生作业：

【图片】

+129
来源：物联网/嵌入式工程师 · linux用户管理-学习任务
得分 100
讨论题

cjozGV 的学生作业：

#include "stdio.h" #include "stdlib.h" #include typedef struct { int data[1024]; int top; } Stack; //初始化栈 void init_stack(Stack *s){ s->top = -1; } //检查栈是否为空 int is_empty(Stack *s){ return s->top == -1; } //压栈 void push(Stack *s,int value){ s->data[++s->top] = value; } //出栈 int pop(Stack *s){ return s->data[s->top--]; } //查看栈顶元素 int peek(Stack *s){ return s->data[s->top]; } //运算符优先级和计算函数 int get_level(char op){ switch (op) { case '+': case '-': return 1; case '*': case '/': return 2; default: return -1; } } //根据运算符执行相应的计算 int compute(int a,int b,int op){ switch (op) { case '+': return a + b; case '-': return a - b; case '*': return a * b; case '/': return a / b; default: return 0; } } //表达式求值函数 int evaluate_expression(const char *expr){ //operands操作数字 operators操作字符 初始化两个栈 Stack operands,operators; init_stack(&operands); init_stack(&operators); while (*expr) { if (isdigit(*expr)) { int num = 0; while (isdigit(*expr)) { num = num * 10 + (*expr - '0'); expr++; } push(&operands, num); continue; } if (*expr == '(') { push(&operators, *expr); } else if (*expr == ')') { while (!is_empty(&operators) && peek(&operators) != '(') { int b = pop(&operands); //从操作数栈弹出 int a = pop(&operands); //从操作数栈弹出 char op = pop(&operators); //从操作符栈弹出 push(&operands, compute(a, b, op)); // 结果压入操作数栈 } pop(&operators); //弹出左括号 } else if (*expr == '+' || *expr == '-' || *expr == '*' || *expr == '/') { //处理运算符：先计算栈中优先级 >= 当前运算符的运算 while (!is_empty(&operators) && get_level(peek(&operators)) >= get_level(*expr)) { int b = pop(&operands); int a = pop(&operands); char op = pop(&operators); push(&operands, compute(a, b, op)); } push(&operators, *expr); //当前运算符压栈 } expr++; //处理下一个字符 } // 处理剩余运算符 while (!is_empty(&operators)) { int b = pop(&operands); int a = pop(&operands); char op = pop(&operators); push(&operands, compute(a, b, op)); } return pop(&operands); // 最终结果在操作数栈顶 } int main() { const char *expression = "(4+8)*2-3"; int result = evaluate_expression(expression); printf("Result: %d\n", result); return 0; }

来源：物联网/嵌入式全能工程师（提薪优选） · 表达式求值升级版
得分 100
学习任务

慕后端3277080 的学生作业：

【图片】【图片】

+126
来源：物联网/嵌入式工程师 · ubuntu 软件安装命令详解-课后任务
得分 100
讨论题

Hee_cryLQ0 的学生作业：

#include #include #include #define MAX 12 typedef char data_t; typedef struct { data_t data[MAX]; int top; }seqstack_t; seqstack_t *create_new_stack() { seqstack_t *s = (seqstack_t *)malloc(sizeof(seqstack_t)); memset(s, 0, sizeof(seqstack_t)); s->top = -1; return s; } data_t is_empty(seqstack_t *stack) { return stack->top == -1 ? 1 : 0; } data_t is_full(seqstack_t *stack) { return stack->top == MAX - 1 ? 1 : 0; } void push_seqstack(seqstack_t *stack, data_t data) { stack->data[++stack->top] = data; return ; } data_t pop_seqstack(seqstack_t *stack) { return stack->data[stack->top--]; } data_t get_top_data(seqstack_t *stack) { return stack->data[stack->top]; } int main() { data_t data[] = {'a','n','i','h','c',' ','e','v','o','l',' ','I'}; data_t pop_data; seqstack_t *stack = create_new_stack(); for(int i = 0; i < MAX; i ++) { push_seqstack(stack, data[i]); } printf("入栈后的栈顶元素是:%c\n", get_top_data(stack)); printf("-----开始出栈-----\n"); for(int i = 0; i < MAX; i++) { pop_data = pop_seqstack(stack); printf("%c",pop_data); } putchar('\n'); return 0; }

+19
来源：物联网/嵌入式全能工程师（提薪优选） · 顺序栈的代码实现-课后练习
得分 100
讨论题

cjozGV 的学生作业：

#include "stdio.h" #include "stdlib.h" #include typedef struct { int data[1024]; int top; } Stack; //初始化栈 void init_stack(Stack *s){ s->top = -1; } //检查栈是否为空 int is_empty(Stack *s){ return s->top == -1; } //压栈 void push(Stack *s,int value){ s->data[++s->top] = value; } //出栈 int pop(Stack *s){ return s->data[s->top--]; } //查看栈顶元素 int peek(Stack *s){ return s->data[s->top]; } //运算符优先级和计算函数 int get_level(char op){ switch (op) { case '+': case '-': return 1; case '*': case '/': return 2; default: return -1; } } //根据运算符执行相应的计算 int compute(int a,int b,int op){ switch (op) { case '+': return a + b; case '-': return a - b; case '*': return a * b; case '/': return a / b; default: return 0; } } //表达式求值函数 int evaluate_expression(const char *expr){ //operands操作数字 operators操作字符 初始化两个栈 Stack operands,operators; init_stack(&operands); init_stack(&operators); while (*expr) { if (isdigit(*expr)) { int num = 0; while (isdigit(*expr)) { num = num * 10 + (*expr - '0'); expr++; } push(&operands, num); continue; } // 如果是运算符，处理优先级并压入运算符栈 if (*expr == '+' || *expr == '-' || *expr == '*' || *expr == '/'){ //如果栈顶运算符的优先级大于或等于当前运算符，则先计算栈顶的运算 while (!is_empty(&operators) && get_level(peek(&operators)) >= get_level(*expr)){ int b = pop(&operands); int a = pop(&operands); char op = pop(&operators); push(&operands, compute(a,b,op)); } push(&operators,*expr); } expr++; } //处理剩余的运算符 while (!is_empty(&operators)){ int b = pop(&operands); int a = pop(&operands); char op = pop(&operators); push(&operands, compute(a,b,op)); } return pop(&operands); } int main() { const char *expression = "1+123*5"; int result = evaluate_expression(expression); printf("Result: %d\n", result); return 0; }

来源：物联网/嵌入式全能工程师（提薪优选） · 表达式求值简单版
得分 100
讨论题

Hee_cryLQ0 的学生作业：

josehp.h #ifndef _JOSEHP_H_ #define _JOSEHP_H_ #include #include #include typedef int datatype_t; typedef struct node { datatype_t data; struct node *next; }linknode_t; extern linknode_t *create_josephlist(); extern void print_josehplist(linknode_t *head); extern void josephlist_function(linknode_t *head, int arr[], int index, int k, int m); #endif //_JOSEHP_H_ josehp.c #include "joseph.h" linknode_t *create_josephlist(const int n) { printf("-----初始化约瑟夫环-----"); linknode_t *head = (linknode_t *)malloc(sizeof(linknode_t));//先创建头结点 linknode_t *p = head; for(int i = 1; i data = i; p->next = temp; //链接新创建的结点 p = temp;//移动p到新的结点 } //跳过头结点连成环，相当于把创建的头结点释放掉，第一个数据结点成为新的头结点 p->next = head->next;//经过插入数据，p已经到链表尾部了，把p的next指向head的next，head被空出来等待释放 linknode_t *q = head; //保存头结点地址 head = head->next; //移动头结点到下一个结点 free(q); //释放掉头结点内存 return head; } void print_josehplist(linknode_t *head) { linknode_t *p = head; // while(p->next != NULL) // { // printf("%d", p->data); // p = p->next; // } // printf("%d", p->next);//由于条件判断的局限性，不加这行打印不出来最后一个结点的值，或者直接改成下面的写法 do{ printf("%d", p->data); p = p->next; }while(p != head); printf("\n"); } void josephlist_function(linknode_t *head, int arr[], int index, int k, int m) { linknode_t *current = head; linknode_t *prev = NULL; for(int i = 1; i < k; i++)//移动到从current结点开始数 { prev = current; current = current->next; } printf("当k值为%d时,约瑟夫环的内容为:\n", k); print_josehplist(current); while(current->next != current) { //current每次移动m个结点 for(int i = 1; i < m; i++) { prev = current; current = current->next; } //移动到m处，把m处的结点信息取出并删除结点(current)，同时current结点向后移动一位。 prev->next = current->next; //printf("%d", current->data); arr[index++] = current->data; //把每次出列的结点保存到数组 free(current); //释放掉已经出列的结点堆内存 current = prev->next; //current继续保存prev前面的结点 } //当环中只有一个结点时跳出循环并取出最后一个值保存进数组 //printf("%d", current->data); arr[index++] = current->data; free(current); current = NULL; //全部出列，指针置空 return ; } main.c #include "joseph.h" int main() { int n = 8, k = 3, m = 4; int arr[8] = {'0'};//保存出列的结点数据 int index = 0; //定义数组下标 linknode_t *head = create_josephlist(n); print_josehplist(head); josephlist_function(head, arr, index, k, m); printf("约瑟夫环出列顺序为:\n"); for(int i = 0; i < 8; i++) { printf("arr[%d] = %d ", i, arr[i]); } printf("\n"); return 0; } 运行结果： 12345678 当k值为3时,约瑟夫环的内容为: 34567812 约瑟夫环出列顺序为: arr[0] = 6 arr[1] = 2 arr[2] = 7 arr[3] = 4 arr[4] = 3 arr[5] = 5 arr[6] = 1 arr[7] = 8

+17
来源：物联网/嵌入式全能工程师（提薪优选） · 单向循环链表-课后任务
得分 100
讨论题

cjozGV 的学生作业：

#include // 直接插入排序函数 void insertionSort(int arr[], int n) { int i, key, j; for (i = 1; i < n; i++) { key = arr[i]; j = i - 1; // 将 arr[i] 插入到已排序的序列 arr[0...i-1] 中 while (j >= 0 && arr[j] > key) { arr[j + 1] = arr[j]; j = j - 1; } arr[j + 1] = key; } } // 打印数组的函数 void printArray(int arr[], int size) { int i; for (i = 0; i < size; i++) printf("%d ", arr[i]); printf("\n"); } // 主函数，用于测试插入排序 int main() { int arr[] = {12, 11, 13, 5, 6}; int n = sizeof(arr) / sizeof(arr[0]); printf("原始数组: \n"); printArray(arr, n); insertionSort(arr, n); printf("排序后的数组: \n"); printArray(arr, n); return 0; } 1.外层循环 直接插入排序有一个外层循环，它遍历数组中的每个元素（除了第一个元素，因为它被认为是已排序的） 如果数组有 n 个元素，外层循环将执行 n−1 次 2.外层循环 对于外层循环中的每个元素，内层循环负责将其插入到已排序部分的正确位置 在平均情况下，假设每个元素都需要与已排序部分的大约一半元素进行比较 这是一个简化的假设，用于说明目的 因此，对于第 i 个元素（i 从 1 开始），内层循环大约需要执行 i/2 次比较（在平均情况下） 3.总操作数 将外层循环和内层循环的操作数相乘 直接插入排序的平均时间复杂度是 O(n2)

+7
来源：物联网/嵌入式全能工程师（提薪优选） · 常用算法平均时间复杂度计算-课后练习
得分 100
学习任务

qq_康斯坦丁_0 的学生作业：

#include #include #include #include #include #include #include #include #define MSG_KEY 1234 #define MAX_MSG_SIZE 256 // 消息结构 struct msg_buffer { long msg_type; char msg_text[MAX_MSG_SIZE]; }; void child_process(int msgid, int type) { struct msg_buffer message; while (1) { if (msgrcv(msgid, &message, sizeof(message.msg_text), type, 0) < 0) { perror(“msgrcv”); exit(1); } printf(“子进程 (类型 %d) 收到消息: %s”, type, message.msg_text); if (strncmp(message.msg_text, “quit”, 4) == 0) { break; } } exit(0); } int main() { int msgid; pid_t pid_a, pid_b; struct msg_buffer message; char input_buffer[MAX_MSG_SIZE]; // 创建消息队列 msgid = msgget(MSG_KEY, 0666 | IPC_CREAT); if (msgid < 0) { perror("msgget"); exit(1); } // 创建子进程A pid_a = fork(); if (pid_a < 0) { perror("fork A"); exit(1); } if (pid_a == 0) { child_process(msgid, 100); } // 创建子进程B pid_b = fork(); if (pid_b < 0) { perror("fork B"); exit(1); } if (pid_b == 0) { child_process(msgid, 200); } // 父进程 printf("父进程启动，请输入要发送的消息 ('quit' 退出):\n"); while (1) { printf("> "); fgets(input_buffer, sizeof(input_buffer), stdin); // 发送给子进程A message.msg_type = 100; strcpy(message.msg_text, input_buffer); if (msgsnd(msgid, &message, sizeof(message.msg_text), 0) < 0) { perror("msgsnd to A"); exit(1); } // 发送给子进程B message.msg_type = 200; strcpy(message.msg_text, input_buffer); if (msgsnd(msgid, &message, sizeof(message.msg_text), 0) < 0) { perror("msgsnd to B"); exit(1); } if (strncmp(input_buffer, "quit", 4) == 0) { break; } } // 等待子进程结束 waitpid(pid_a, NULL, 0); waitpid(pid_b, NULL, 0); // 删除消息队列 if (msgctl(msgid, IPC_RMID, NULL) < 0) { perror("msgctl"); exit(1); } printf("父进程退出\n"); return 0; }

+11
来源：物联网/嵌入式全能工程师（提薪优选） · 消息队列的发送与接收-课后任务
得分 100
学习任务

慕少6127043 的学生作业：

#include int main() { int yeay = 0; printf(“请输入年份”); scanf("%d",&yeay); if((yeay % 4 == 0 && yeay % 100 != 0) || (yeay % 400 ==0) { printf("%d yeay is leap yeay!\n",yeay); }else{ printf("%d yeay is not yeay!\n",yeay); } return 0; }

+22
来源：嵌入式软件工程师 · C语言中的if多分支语句-课后学习任务
得分 100
学习任务

慕少6127043 的学生作业：

#include int main() { int data = 0; printf(“请输入数字”); scanf("%d",&data); if(data % 2) { data++; }else{ data–; } printf(“data = %d\n”,data); return 0; }

+22
来源：嵌入式软件工程师 · C语言中if单分支语句-课后学习任务
得分 100
讨论题

火烛明 的学生作业：

#include int main(void){ printf("\033[2J"); printf("\033[5;10H"); printf("\033[31m"); printf("hello world\n"); printf("\033[?25h"); printf("\033[0m"); return 0; }

+24
来源：物联网/嵌入式全能工程师（提薪优选） · vt100控制码介绍-课后练习
得分 100
学习任务

火烛明 的学生作业：

using namespace std; extern int my_swap(float a, float b); extern int my_swap(int a, int b); extern int my_swap(string a, string b); int main(void){ my_swap((float)1.1, (float)1.2); my_swap(1, 30); my_swap("hello", "world"); return 0; } int my_swap(float a, float b){ std::cout

+9
来源：物联网/嵌入式全能工程师（提薪优选） · 函数增强部分-课后任务
得分 100
学习任务

火烛明 的学生作业：

#include int main(void) { int data = 100; std::string str = "hello world"; int a[] = {1,2,3,4,5,6,7}; std::cout

+8
来源：物联网/嵌入式全能工程师（提薪优选） · C++初步介绍-课后任务
得分 98
学习任务

火烛明 的学生作业：

#include using namespace std; void change(int &a) { a ++; } void printf_string(const string &str) { cout

+10
来源：物联网/嵌入式全能工程师（提薪优选） · C++引用相关练习
得分 100
项目作业

anqilin 的作业评语：

程序运行结果符合题目要求，程序严谨，逻辑结构清晰！继续加油！祝学习愉快！

+50
来源：Python全能工程师 · 【项目作业】学生管理系统
得分 100
学习任务

RX0_UNICORN 的学生作业：

ID(A) = 2，B --> A, C --> A OD(A) = 1, A --> D D(A) = ID(A) + OD(A) = 2 + 1 = 3

+16
来源：物联网/嵌入式全能工程师（提薪优选） · 图的基本概念讲解-学习任务
得分 100
学习任务

RX0_UNICORN 的学生作业：

【图片】

+11
来源：物联网/嵌入式全能工程师（提薪优选） · 哈夫曼编码-课后练习
得分 98
学习任务

RX0_UNICORN 的学生作业：

// linkstack.h #ifndef __LINKSTACK_H__ #define __LINKSTACK_H__ #include #include #include #include "bitree.h" typedef bitree_t *datatype_t; // 节点类型 typedef struct node { datatype_t data; struct node *next; }linknode_t; // 栈头类型 typedef struct { linknode_t *top; // 栈顶指针 int n; // 记录当前栈中元素的个数 }linkstack_t; extern linkstack_t *create_empty_linkstack(); extern int is_empty_linkstack(linkstack_t *ls); extern void push_linkstack(linkstack_t *ls, datatype_t data); extern datatype_t pop_linkstack(linkstack_t *ls); extern datatype_t get_top_data(linkstack_t *ls); #endif // linkstack.c #include "linkstack.h" linkstack_t *create_empty_linkstack() { linkstack_t *ls = NULL; ls = (linkstack_t *)malloc(sizeof(linkstack_t)); if(NULL == ls) { printf("malloc linkstack_t *ls is fail!\n"); return NULL; } memset(ls, 0, sizeof(linkstack_t)); return ls; } // 判空 int is_empty_linkstack(linkstack_t *ls) { return ls->top == NULL ? 1 : 0; } // 入栈 void push_linkstack(linkstack_t *ls, datatype_t data) { linknode_t *temp = NULL; temp = (linknode_t *)malloc(sizeof(linknode_t)); if(NULL == temp) { printf("malloc linknode_t *temp is fail!\n"); return; } temp->data = data; // 将节点数据插入栈中 temp->next = ls->top; ls->top = temp; // 更新n 的值 ls->n++; return; } datatype_t pop_linkstack(linkstack_t *ls) { linknode_t *temp = NULL; datatype_t data; // 保存要删除的节点地址 temp = ls->top; // 取出数据 data = temp->data; // 更新头部指针 ls->top = temp->next; // 释放 temp free(temp); temp = NULL; // 更新 n 的值 ls->n--; return data; } // 输出栈顶元素 datatype_t get_top_data(linkstack_t *ls) { return ls->top->data; } // bitree.h #ifndef __BITREE_H__ #define __BITREE_H__ #include #include #include #define N 6 typedef char data_t; typedef struct bitree { int n; data_t data; struct bitree *lchild; struct bitree *rchild; }bitree_t; extern bitree_t *create_empty_bitree(int n); extern void pre_order(bitree_t *bt); extern void in_order(bitree_t *bt); extern void post_order(bitree_t *bt); #endif // bitree.c #include "bitree.h" #include "linkstack.h" bitree_t *create_empty_bitree(int n) { bitree_t *bt = NULL; bt = (bitree_t *)malloc(sizeof(bitree_t)); if(NULL == bt) { printf("malloc bitree_t *bt is fail!\n"); return NULL; } memset(bt, 0, sizeof(bitree_t)); bt->n = n; bt->lchild = bt->rchild = NULL; printf("input %d node data : ", n); scanf("%c", &(bt->data)); // 清除缓存区数据 while(getchar() != '\n'); // 左子节点存在条件 if(2 * n lchild = create_empty_bitree(2 * n); } // 右子节点存在条件 if(2 * n + 1 rchild = create_empty_bitree(2 * n + 1); } return bt; } // 前序非递归遍历 void pre_order(bitree_t *bt) { if(bt == NULL) return; linkstack_t *ls = create_empty_linkstack(); bitree_t *temp = bt; while(temp != NULL || !is_empty_linkstack(ls)) { while(temp != NULL) { printf("(%c : %d)", temp->data, temp->n); push_linkstack(ls, temp); temp = temp->lchild; } if(!is_empty_linkstack(ls)) { temp = pop_linkstack(ls); temp = temp->rchild; } } free(ls); return; } //中序遍历 void in_order(bitree_t *root) { if(NULL == root) return ; linkstack_t *ls = create_empty_linkstack(); bitree_t *temp = root; while(temp != NULL || !is_empty_linkstack(ls)) { if(temp != NULL) { push_linkstack(ls, temp); temp = temp->lchild; } else { temp = pop_linkstack(ls); printf("(%c : %d)",temp->data,temp->n); temp = temp->rchild; } } free(ls); } //后序遍历 void post_order(bitree_t *root) { if(NULL == root) return ; linkstack_t *ls = create_empty_linkstack(); bitree_t *pre = NULL; bitree_t *cur = NULL; push_linkstack(ls, root); while(!is_empty_linkstack(ls)) { cur = get_top_data(ls); // 以下情况，可以直接输出值 // 左右孩子都为空 // 左右孩子存在，并且左孩子或右孩子都被访问过 if((cur->lchild == NULL && cur->rchild == NULL) || (pre != NULL && (pre == cur->lchild || pre == cur->rchild))) { printf("(%c : %d) ",cur->data,cur->n); pop_linkstack(ls); pre = cur; } else { if(cur->rchild != NULL) { push_linkstack(ls, cur->rchild); } if(cur->lchild != NULL) { push_linkstack(ls, cur->lchild); } } } free(ls); return; } // main.c #include "bitree.h" int main(int argc, const char *argv[]) { bitree_t *bt = create_empty_bitree(1); printf("pre_order : "); pre_order(bt); printf("\n"); printf("in_order : "); in_order(bt); printf("\n"); printf("post_order : "); post_order(bt); printf("\n"); return 0; } 【图片】

+12
来源：物联网/嵌入式全能工程师（提薪优选） · 非递归遍历之后序遍历-学习任务
得分 100
学习任务

cjozGV 的学生作业：

void selectionSort(unsigned char *p, int n) { for (int i = 0; i < n - 1; i++) { int k = i; // 记录最小值的索引 for (int j = i + 1; j < n; j++) { // 从 i+1 开始比较 if (p[j] < p[k]) { k = j; // 更新最小值的索引 } } // 交换放在外层循环，仅交换一次 if (k != i) { int temp = p[i]; p[i] = p[k]; p[k] = temp; } } } int main() { unsigned char str[] = "decba"; int n = strlen((char *)str); // 更安全的方式（如果 str 是字符串） // 或者： // int n = sizeof(str) / sizeof(str[0]) - 1; // 去掉 '\0' printf("排序前: %s\n", str); selectionSort((char *)str, n); printf("排序后: %s\n", str); return 0; }

+13
来源：物联网/嵌入式全能工程师（提薪优选） · 简单选择排序
首页上一页12131415161718下一页尾页
查看课程
查看课程
查看课程
微信客服

购课补贴
联系客服咨询优惠详情

 帮助反馈 APP下载

慕课网APP
您的移动学习伙伴

 公众号

扫描二维码
关注慕课网微信公众号