数据结构——浙大版中国大学mooc(week2)

数据结构——浙大版中国大学mooc(week10) 排序(下)课程给出代码10-排序4 统计工龄 (20 分)10-排序5 PAT Judge (25 分)10-排序6 Sort with Swap(0, i) (25 分) 课程给出代码 C语言:快速排序 /* 快速排序 - 直接调用库函数 */ #include <stdlib.h> /*---------------简单整数排序--------------------*/ ... 阅读详情

课程给出代码

C语言描述顺序表操作

typedef int Position;
typedef struct LNode *List;
struct LNode {
    ElementType Data[MAXSIZE];
    Position Last;
};
 
/* 初始化 */
List MakeEmpty()
{
    List L;
 
    L = (List)malloc(sizeof(struct LNode));
    L->Last = -1;
 
    return L;
}
 
/* 查找 */
#define ERROR -1
 
Position Find( List L, ElementType X )
{
    Position i = 0;
 
    while( i <= L->Last && L->Data[i]!= X )
        i++;
    if ( i > L->Last )  return ERROR; /* 如果没找到,返回错误信息 */
    else  return i;  /* 找到后返回的是存储位置 */
}
 
/* 插入 */
/*注意:在插入位置参数P上与课程视频有所不同,课程视频中i是序列位序(从1开始),这里P是存储下标位置(从0开始),两者差1*/
bool Insert( List L, ElementType X, Position P ) 
{ /* 在L的指定位置P前插入一个新元素X */
    Position i;
 
    if ( L->Last == MAXSIZE-1) {
        /* 表空间已满,不能插入 */
        printf("表满"); 
        return false; 
    }  
    if ( P<0 || P>L->Last+1 ) { /* 检查插入位置的合法性 */
        printf("位置不合法");
        return false; 
    } 
    for( i=L->Last; i>=P; i-- )
        L->Data[i+1] = L->Data[i]; /* 将位置P及以后的元素顺序向后移动 */
    L->Data[P] = X;  /* 新元素插入 */
    L->Last++;       /* Last仍指向最后元素 */
    return true; 
} 
 
/* 删除 */
/*注意:在删除位置参数P上与课程视频有所不同,课程视频中i是序列位序(从1开始),这里P是存储下标位置(从0开始),两者差1*/
bool Delete( List L, Position P )
{ /* 从L中删除指定位置P的元素 */
    Position i;
 
    if( P<0 || P>L->Last ) { /* 检查空表及删除位置的合法性 */
        printf("位置%d不存在元素", P ); 
        return false; 
    }
    for( i=P+1; i<=L->Last; i++ )
        L->Data[i-1] = L->Data[i]; /* 将位置P+1及以后的元素顺序向前移动 */
    L->Last--; /* Last仍指向最后元素 */
    return true;   
}

C语言描述链表

typedef struct LNode *PtrToLNode;
struct LNode {
    ElementType Data;
    PtrToLNode Next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;
 
/* 查找 */
#define ERROR NULL
 
Position Find( List L, ElementType X )
{
    Position p = L; /* p指向L的第1个结点 */
 
    while ( p && p->Data!=X )
        p = p->Next;
 
    /* 下列语句可以用 return p; 替换 */
    if ( p )
        return p;
    else
        return ERROR;
}
 
/* 带头结点的插入 */
/*注意:在插入位置参数P上与课程视频有所不同,课程视频中i是序列位序(从1开始),这里P是链表结点指针,在P之前插入新结点 */
bool Insert( List L, ElementType X, Position P )
{ /* 这里默认L有头结点 */
    Position tmp, pre;
 
    /* 查找P的前一个结点 */        
    for ( pre=L; pre&&pre->Next!=P; pre=pre->Next ) ;            
    if ( pre==NULL ) { /* P所指的结点不在L中 */
        printf("插入位置参数错误\n");
        return false;
    }
    else { /* 找到了P的前一个结点pre */
        /* 在P前插入新结点 */
        tmp = (Position)malloc(sizeof(struct LNode)); /* 申请、填装结点 */
        tmp->Data = X; 
        tmp->Next = P;
        pre->Next = tmp;
        return true;
    }
}
 
/* 带头结点的删除 */
/*注意:在删除位置参数P上与课程视频有所不同,课程视频中i是序列位序(从1开始),这里P是拟删除结点指针 */
bool Delete( List L, Position P )
{ /* 这里默认L有头结点 */
    Position tmp, pre;
 
    /* 查找P的前一个结点 */        
    for ( pre=L; pre&&pre->Next!=P; pre=pre->Next ) ;            
    if ( pre==NULL || P==NULL) { /* P所指的结点不在L中 */
        printf("删除位置参数错误\n");
        return false;
    }
    else { /* 找到了P的前一个结点pre */
        /* 将P位置的结点删除 */
        pre->Next = P->Next;
        free(P);
        return true;
    }
}

C语言描述顺序栈

typedef int Position;
struct SNode {
    ElementType *Data; /* 存储元素的数组 */
    Position Top;      /* 栈顶指针 */
    int MaxSize;       /* 堆栈最大容量 */
};
typedef struct SNode *Stack;
 
Stack CreateStack( int MaxSize )
{
    Stack S = (Stack)malloc(sizeof(struct SNode));
    S->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
    S->Top = -1;
    S->MaxSize = MaxSize;
    return S;
}
 
bool IsFull( Stack S )
{
    return (S->Top == S->MaxSize-1);
}
 
bool Push( Stack S, ElementType X )
{
    if ( IsFull(S) ) {
        printf("堆栈满");
        return false;
    }
    else {
        S->Data[++(S->Top)] = X;
        return true;
    }
}
 
bool IsEmpty( Stack S )
{
    return (S->Top == -1);
}
 
ElementType Pop( Stack S )
{
    if ( IsEmpty(S) ) {
        printf("堆栈空");
        return ERROR; /* ERROR是ElementType的特殊值,标志错误 */
    }
    else 
        return ( S->Data[(S->Top)--] );
}

C语言描述链栈

typedef struct SNode *PtrToSNode;
struct SNode {
    ElementType Data;
    PtrToSNode Next;
};
typedef PtrToSNode Stack;
 
Stack CreateStack( ) 
{ /* 构建一个堆栈的头结点,返回该结点指针 */
    Stack S;
 
    S = (Stack)malloc(sizeof(struct SNode));
    S->Next = NULL;
    return S;
}
 
bool IsEmpty ( Stack S )
{ /* 判断堆栈S是否为空,若是返回true;否则返回false */
    return ( S->Next == NULL );
}
 
bool Push( Stack S, ElementType X )
{ /* 将元素X压入堆栈S */
    PtrToSNode TmpCell;
 
    TmpCell = (PtrToSNode)malloc(sizeof(struct SNode));
    TmpCell->Data = X;
    TmpCell->Next = S->Next;
    S->Next = TmpCell;
    return true;
}
 
ElementType Pop( Stack S )  
{ /* 删除并返回堆栈S的栈顶元素 */
    PtrToSNode FirstCell;
    ElementType TopElem;
 
    if( IsEmpty(S) ) {
        printf("堆栈空"); 
        return ERROR;
    }
    else {
        FirstCell = S->Next; 
        TopElem = FirstCell->Data;
        S->Next = FirstCell->Next;
        free(FirstCell);
        return TopElem;
    }
}

C语言描述顺序队列

typedef int Position;
struct QNode {
    ElementType *Data;     /* 存储元素的数组 */
    Position Front, Rear;  /* 队列的头、尾指针 */
    int MaxSize;           /* 队列最大容量 */
};
typedef struct QNode *Queue;
 
Queue CreateQueue( int MaxSize )
{
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
    Q->Front = Q->Rear = 0;
    Q->MaxSize = MaxSize;
    return Q;
}
 
bool IsFull( Queue Q )
{
    return ((Q->Rear+1)%Q->MaxSize == Q->Front);
}
 
bool AddQ( Queue Q, ElementType X )
{
    if ( IsFull(Q) ) {
        printf("队列满");
        return false;
    }
    else {
        Q->Rear = (Q->Rear+1)%Q->MaxSize;
        Q->Data[Q->Rear] = X;
        return true;
    }
}
 
bool IsEmpty( Queue Q )
{
    return (Q->Front == Q->Rear);
}
 
ElementType DeleteQ( Queue Q )
{
    if ( IsEmpty(Q) ) { 
        printf("队列空");
        return ERROR;
    }
    else  {
        Q->Front =(Q->Front+1)%Q->MaxSize;
        return  Q->Data[Q->Front];
    }
}

C语言描述链队列

typedef struct Node *PtrToNode;
struct Node { /* 队列中的结点 */
    ElementType Data;
    PtrToNode Next;
};
typedef PtrToNode Position;
 
struct QNode {
    Position Front, Rear;  /* 队列的头、尾指针 */
    int MaxSize;           /* 队列最大容量 */
};
typedef struct QNode *Queue;
 
bool IsEmpty( Queue Q )
{
    return ( Q->Front == NULL);
}
 
ElementType DeleteQ( Queue Q )
{
    Position FrontCell; 
    ElementType FrontElem;
     
    if  ( IsEmpty(Q) ) {
        printf("队列空");
        return ERROR;
    }
    else {
        FrontCell = Q->Front;
        if ( Q->Front == Q->Rear ) /* 若队列只有一个元素 */
            Q->Front = Q->Rear = NULL; /* 删除后队列置为空 */
        else                     
            Q->Front = Q->Front->Next;
        FrontElem = FrontCell->Data;
 
        free( FrontCell );  /* 释放被删除结点空间  */
        return  FrontElem;
    }
}

02-线性结构1 两个有序链表序列的合并 (15 分)

在这里插入图片描述

List Merge( List L1, List L2 )//合并函数本题需要写的函数
{
    List pa,pb,pc,L;
    L = (List)malloc(sizeof(struct Node));
    pa=L1->Next;
    pb=L2->Next;
    pc = L;           //pc用来存储中间值,L用来存表头位置
    while(pa && pb)
    {
        if(pa->Data <= pb->Data)
        {
            pc->Next = pa;
            pc = pa;
            pa = pa->Next;
        }
        else
        {
            pc->Next = pb;
            pc = pb;
            pb = pb->Next;
        }
    }
    pc->Next = pa ? pa : pb;//接上未空表的数据
    L1->Next = NULL;
    L2->Next = NULL;
    return L;
}

02-线性结构2 一元多项式的乘法与加法运算 (20 分)

题目:
设计函数分别求两个一元多项式的乘积与和。
输入格式:
输入分2行,每行分别先给出多项式非零项的个数,再以指数递降方式输入一个多项式非零项系数和指数(绝对值均为不超过1000的整数)。数字间以空格分隔。
输出格式:
输出分2行,分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数。数字间以空格分隔,但结尾不能有多余空格。零多项式应输出0 0。

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

typedef struct PolyNode *Polynomial;
struct PolyNode{
	int coef;
	int expon;
	Polynomial link;
};

void Attach(int c,int e,Polynomial *pRear){
	Polynomial temp;
    temp=(Polynomial)malloc(sizeof(Polynomial));   
    temp->coef=c;
    temp->expon=e;
    temp->link=NULL;
    (*pRear)->link=temp;
    *pRear=temp;      //此处要加*,因为引入的是p的地址
}

Polynomial ReadPoly(){
	int n,c,e;
	Polynomial temp,p;
	p=(Polynomial)malloc(sizeof(Polynomial));
	p->link=NULL;
	temp=p;
	scanf("%d",&n);
	while(n--){
        scanf("%d %d",&c,&e);
        Attach(c,e,&temp);
    }
	return p->link;//返回的不带表头的链表
}

Polynomial Add(Polynomial p1,Polynomial p2)
{
    Polynomial p,temp,p0;
    p=(Polynomial)malloc(sizeof(Polynomial));
    p->link=NULL;
    temp=p;
    while(p1&&p2){
        if(p1->expon>p2->expon){
			Attach(p1->coef,p1->expon,&p); 
			p1=p1->link;
		}
        else if(p1->expon<p2->expon){
			Attach(p2->coef,p2->expon,&p);
			p2=p2->link;
		}
        else if(p1->coef+p2->coef==0){
            p1=p1->link;    
			p2=p2->link;
        }
        else{
            Attach(p1->coef+p2->coef,p1->expon,&p);
			p1=p1->link;
			p2=p2->link;
        }
    }
    while(p1) {Attach(p1->coef,p1->expon,&p); p1=p1->link;}
    while(p2) {Attach(p2->coef,p2->expon,&p); p2=p2->link;}//后接剩下的
    p0=temp; temp=temp->link; free(p0);//去掉临时的表头,输出temp—>link也成
    return temp;
}

Polynomial Mult(Polynomial p1,Polynomial p2)
{
    Polynomial p,temp,t1,t2,temp1,t;
    t1=p1; t2=p2;
    p=(Polynomial)malloc(sizeof(struct PolyNode));
    p->link=NULL;
    temp=p;
    if(!t1||!t2)
		return NULL;
    while(t2) {//表一的第一项与表二所有项相乘
        Attach((t1->coef)*(t2->coef),(t1->expon)+(t2->expon),&temp);
        t2=t2->link;
    }
    t1=t1->link;
    while(t1)//计算剩下的相乘项并插入到之前的数据中
    {
        t2=p2;//回到表二的表头准备与表一的下一项相乘
        while(t2)
        {
			temp=p;//重新回到结果表的表头
            while((temp->link)&&((t1->expon)+(t2->expon)<(temp->link)->expon))
                temp=temp->link;
            if ((temp->link)&&((t1->expon)+(t2->expon)==temp->link->expon))
            {
                if((t1->coef)*(t2->coef)+temp->link->coef==0){
                    temp1=temp->link;   
					temp->link=temp1->link; 
					free(temp1);
                }//这种情况是系数为零了因此要去掉这一项
                else{
                    temp->link->coef+=(t1->coef)*(t2->coef);
                }
            }
            else{//不等只能大于则在前面插入这项
			
                t=(Polynomial)malloc(sizeof(struct PolyNode));
                t->coef=t1->coef*t2->coef; 
				t->expon=t1->expon+t2->expon;
                t->link=temp->link;
                temp->link=t;
                temp=temp->link;
            }
            t2=t2->link;
        }
        t1=t1->link;//提出表一的下一项准备相乘
    }
    temp=p; p=p->link; free(temp);//去掉临时表头
    return p;
}

void PrintPoly(Polynomial p)
{
    int flag=0;
    if(!p) {printf("0 0\n"); return;}
    while(p){
        if(!flag) 
			flag=1;
        else     
			printf(" ");
        printf("%d %d",p->coef,p->expon);
        p=p->link;
    }
	printf("\n");
}

int main(){
	Polynomial P1,P2,PP,PS;
	P1=ReadPoly();
	P2=ReadPoly();
	PP=Mult(P1,P2);
	PrintPoly(PP);
	PS=Add(P1,P2);
	PrintPoly(PS);
	return 0;
}

02-线性结构3 Reversing Linked List (25 分)

Given a constant K and a singly linked list L, you are supposed to reverse the links of every K elements on L. For example, given L being 1→2→3→4→5→6, if K=3, then you must output 3→2→1→6→5→4; if K=4, you must output 4→3→2→1→5→6.
在这里插入图片描述
注意是每隔K个元素翻转一次,不足K个元素则按原序输出。
题目给的测试例子是每个节点都有用到,而测试点中有些节点是没有用到的,所以要先找到在同一条链表的节点。

#include <iostream>
using namespace std;

typedef struct Node *N;
struct Node {
	int data;
	int next;
}L[100000];

void Read(int n){
    int i,p;
    for (i = 0; i < n; i++) {
		cin >> p;
		cin >> L[p].data >> L[p].next;
	}
}

int Search(int pin,int K) {//查找第K个值即确定翻转范围
	int i = K-1;
	while(i-- && pin!=-1){
		pin = L[pin].next;
	}
	return pin;
}

void Done(int* pin, int *plast) {
	int pp = L[*plast].next;
	int p = *pin;
	int pn = L[p].next;
	while (1) {
		L[p].next = pp;
		pp = p;
		if (pp == *plast) {
			break;
		}
		p = pn;
		pn = L[pn].next;
	}//前面改了next的值使pin到plast的顺序翻转为了让这部分重新接入到序列中
	int tmp = *pin;
	*pin = *plast;
	*plast = tmp;//这三行完成了首尾互换
}

void Reverse(int *p,int K){
    int p_K;//K翻转时对应的值(第K值)
    while (*p != -1) {
		p_K = Search(*p,K);
		if (p_K == -1)//剩余的值不够K个则剩下的值不翻转
			break;
		Done(p, &p_K);//进行翻转
		p = &L[p_K].next;//每K个值一循环
	}
}

void Print(int front){
	while (1) {
		printf("%05d %d ", front, L[front].data);
		front = L[front].next;
		if (front == -1) {
			printf("-1\n");
			break;
		}
		printf("%05d\n", front);
	}
}

int main(){
    int front, n, K;//记录头结点地址,节点数,翻转因子
	cin >> front>> n >> K;
	Read(n);
	Reverse(&front,K);
    Print(front);
    return 0;
}

02-线性结构4 Pop Sequence (25 分)

Given a stack which can keep M numbers at most. Push N numbers in the order of 1, 2, 3, …, N and pop randomly. You are supposed to tell if a given sequence of numbers is a possible pop sequence of the stack. For example, if M is 5 and N is 7, we can obtain 1, 2, 3, 4, 5, 6, 7 from the stack, but not 3, 2, 1, 7, 5, 6, 4.
Input Specification:
Each input file contains one test case. For each case, the first line contains 3 numbers (all no more than 1000): M (the maximum capacity of the stack), N (the length of push sequence), and K (the number of pop sequences to be checked). Then K lines follow, each contains a pop sequence of N numbers. All the numbers in a line are separated by a space.
Output Specification:
For each pop sequence, print in one line “YES” if it is indeed a possible pop sequence of the stack, or “NO” if not.

#include<iostream>

using namespace std;

int stack[1000];//建立一个栈

int main(){
	int m, n, t;
	cin >> m >> n >> t;
	while (t--){
		int num, top = 0, flag = 1, now = 1;//待比较的出栈元素;栈顶元素;判断标志;表示当前的值
		for (int i = 0; i < n; i++){//遍历每一个数
			cin >> num;
			while ((top == 0 || num != stack[top]) && flag){//栈为空或者待出栈元素与栈顶元素不相等
				stack[++top] = now;
				if (top > m){//栈已超
					flag = 0;
					break;
				}
				now++;
			}//这个while只是计算一个数有没有可能被push出一共有n个数
			if (num == stack[top] && flag && top >= 1)//栈不为空且待出栈元素与栈顶元素相等则出栈
				top--;
		}
		if (flag)
			printf("YES\n");
		else 
			printf("NO\n");
	}
}
一元多项式乘法算法 NULL 博文链接:https://qingdaoguy.iteye.com/blog/694445 立即下载

相关推荐

中国大学MOOC浙江大学数据结构课程____数据结构作业

中国大学MOOC浙江大学数据结构课程____数据结构作业

数据结构——浙大版中国大学mooc(week7)

图(中)课程给出代码07-图4 哈利·波特的考试 (25 分)07-图5 Saving James Bond - Hard Version (30 分)07-图6 旅游规划 (25 分) 课程给出代码 C语言:邻接表存储 - 无权图的单源最短路算法 /* 邻接表存储 - 无权图的单源最短路算法 */ /* dist[]和path[]全部初始化为-1 */ void Unweighted ( L...

CodingW的博客 485

服务器测试之intel E8102CQDA2

网卡性能 iperf E810

qq_41897488的博客 2509

一元多项式的乘法与加法运算

一元多项式的乘法与加法运算 题目: 设计函数分别求两个一元多项式的乘积与和。 输入格式: 输入分2行,每行分别先给出多项式非零项的个数,再以指数递降方式输入一个多项式非零项系数和指数(绝对值均为不超过1000的整数)。数字间以空格分隔。 输出格式: 输出分2行,分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数。数字间以空格分隔,但结尾不能有多余空格。零多项式应输出0 0。 输入样例:...

weixin_45708385的博客 672

从HPPC测试到Simulink仿真:锂电池二阶RC模型参数辨识完整流程

本文详细介绍了从HPPC测试到Simulink仿真的锂电池二阶RC模型参数辨识完整流程。通过HPPC测试获取实验数据,利用Simulink的Parameter Estimation工具进行参数辨识和模型验证,为BMS算法开发提供精确的电池模型。文章涵盖测试设计、数据预处理、模型搭建及工程应用等关键步骤,助力新能源电池研发。

whisky的博客 686

智能驾驶小白必看:MEB低速紧急制动系统的工作原理与传感器配置详解

本文深入解析了MEB低速紧急制动系统的工作原理与传感器配置。该系统作为智能驾驶的关键安全冗余,专为应对停车场、拥堵路段等复杂低速场景设计。文章详细拆解了其如何通过超声波雷达、环视摄像头等传感器融合感知环境,并基于碰撞时间(TTC)等模型进行风险评估与分级制动,最终实现主动防碰撞,是智能驾驶技术实用化的重要体现。

c2d3e4f的博客 1132

7-1 一元多项式的乘法与加法运算 (20 分)

7-1 一元多项式的乘法与加法运算 (20 分) 设计函数分别求两个一元多项式的乘积与和。 输入格式: 输入分2行,每行分别先给出多项式非零项的个数,再以指数递降方式输入一个多项式非零项系数和指数(绝对值均为不超过1000的整数)。数字间以空格分隔。 输出格式: 输出分2行,分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数。数字间以空格分隔,但结尾不能有多余空格。零多项式应输出0...

xixi0209的博客 4906

基于STM32L4XX、HAL库的ESP32-S3-WROOM-1-N4 WIFI模块驱动程序设计

/ 检查是否收到完整的一行(以\r\n结尾)// 例如: 解析AT命令响应或MQTT消息等。// UART2初始化已在CubeMX中配置。// USART2初始化函数(由CubeMX生成)// 缓冲区溢出,重置。// 如果需要等待响应。// 处理接收到的数据。// 处理接收到的数据。// 等待ESP32模块启动。// 主循环其他任务。// 启用UART全局中断。// 发送HTTP GET请求。// 发送AT测试命令。// 连接Wi-Fi。// UART中断回调函数。

zhusl6688的博客 290

数据结构:一元多项式的乘法与加法运算

中国大学MOOC视屏讲解 设计函数分别求两个一元多项式的乘积与和。 输入格式: 输入分2行,每行分别先给出多项式非零项的个数,再以指数递降方式输入一个多项式非零项系数和指数(绝对值均为不超过1000的整数)。数字间以空格分隔。 输出格式: 输出分2行,分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数。数字间以空格分隔,但结尾不能有多余空格。零多项式应输出0 0。 输入样例: ...

稀饭 2万+

别再让 AI 瞎写 SAP 代码了!这套 Claude Code Skill 的验证机制才是关键

本文深入解析了专为SAP CAP开发设计的AI辅助工具sap-cap-capire的技术架构。该工具采用四层设计:协议层集成MCP和LSP实现实时模型访问与语法检查;智能层通过4个专业化Agent(数据建模、服务开发等)分工协作;验证层确保代码质量;知识层存储文档模板。这种工程化设计解决了通用AI在CAP开发中面临的上下文不足、专业性缺失和代码质量保证等核心问题,通过本地化服务和实时反馈机制显著提升了开发效率。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 883

全国(山东、安徽)职业技能大赛--信息安全管理与评估大赛题目+答案讲解——windows应急响应篇

保护数据,捍卫安全,展现技能,赢得荣耀!全国职业技能大赛-信息安全与评估大赛,挑战你的技术,揭示黑客的秘密!加入我们,成为信息安全的守护者!

人若无名,便可专心练剑 911

数据结构——浙大版中国大学mooc(week5)

树(下)课程给出代码05-树7 堆中的路径 (25 分)05-树8 File Transfer (25 分)05-树9 Huffman Codes (30 分) 课程给出代码 C语言描述:堆的描述和操作 typedef struct HNode *Heap; /* 堆的类型定义 */ struct HNode { ElementType *Data; /* 存储元素的数组 */ i...

CodingW的博客 393

问答式AI vs 智能体(Agent):它们有什么不同?

你肯定用过 ChatGPT 或文心一言——问它一个问题,它给你一个答案。AI Agent(AI智能体)。很多人搞不清楚:它们不都是"AI"吗?有什么区别?这篇文章用一个最简单的类比,彻底讲清楚这两者的本质差异。框架特点适合人群AutoGPT完全自主执行任务,链式思考开发者MetaGPT模拟团队协作,多角色分工开发者LangChain最流行的Agent开发框架开发者Dify可视化无代码搭建Agent非技术用户Coze(扣子)字节跳动出品,国内最易用普通用户WorkBuddy。

Johnny2004的专栏 449

数据结构——浙大版中国大学mooc(week8)

图(下)课程给出代码08-图7 公路村村通 (30 分)08-图8 How Long Does It Take (25 分)08-图9 关键活动 (30 分) 课程给出代码 C语言:邻接矩阵存储 - Prim最小生成树算法 /* 邻接矩阵存储 - Prim最小生成树算法 */ Vertex FindMinDist( MGraph Graph, WeightType dist[] ) { /* ...

CodingW的博客 365

infercnv的实操

摘要: 博主在infercnv分析中遇到执行困难,外包服务不可靠(未按要求使用HMM方法)。通过优化策略(逐样本处理、精简细胞至1000个、固定随机种子)解决了运行问题,但HMM功能仍无法实现。最终参考Cell期刊标准设置阈值完成分析,后续将继续更新进展。该案例凸显了生物信息分析中自主优化的重要性。(150字)

xiaoyusang的博客 310

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

数据结构——浙大版中国大学mooc(week6)

图(上)课程给出代码06-图1 列出连通集 (25 分)06-图2 Saving James Bond - Easy Version (25 分)06-图3 六度空间 (30 分) 课程给出代码 C语言:图的邻接矩阵实现建立 /* 图的邻接矩阵表示法 */ #define MaxVertexNum 100 /* 最大顶点数设为100 */ #define INFINITY 65535 ...

CodingW的博客 365

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

数据结构——浙大版中国大学mooc(week3)

树(上)03-树1 树的同构 (25 分)03-树2 List Leaves (25 分)03-树3 Tree Traversals Again (25 分) 03-树1 树的同构 (25 分) 题目:给定两棵树T1和T2。如果T1可以通过若干次左右孩子互换就变成T2,则我们称两棵树是“同构”的。例如图1给出的两棵树就是同构的,因为我们把其中一棵树的结点A、B、G的左右孩子互换后,就得到另外一棵树...

CodingW的博客 300

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

数据结构——浙大版中国大学mooc(week9)

排序(上)课程给出代码09-排序1 排序 (25 分)09-排序2 Insert or Merge (25 分)09-排序3 Insertion or Heap Sort (25 分) 课程给出代码 C语言:插入排序 void InsertionSort( ElementType A[], int N ) { /* 插入排序 */ int P, i; ElementType T...

CodingW的博客 403

数据结构——浙大版中国大学mooc(week1)

二分查找与最大子列和课程给出代码01-复杂度3 二分查找 (20 分)01-复杂度1 最大子列和问题 (20 分)01-复杂度2 Maximum Subsequence Sum (25 分) 课程给出代码 第一周的课程主要就是给出了一个例子即最大子数列和的问题,在这基础上提出了四种解决方案,其中第三种和第四种最为实用,下面代码给出的是第三种方法即分而治之。有点像二分法但采用了递归,对内存的损耗较大...

CodingW的博客 274

数据结构——浙大版中国大学mooc(week4)

树(中)课程给出代码课程给出代码课程给出代码课程给出代码课程给出代码 课程给出代码 C语言表示二叉搜索树的插入和搜索 BinTree Insert( BinTree BST, ElementType X ) { if( !BST ){ /* 若原树为空,生成并返回一个结点的二叉搜索树 */ BST = (BinTree)malloc(sizeof(struct TNode)...

CodingW的博客 315

浙大Mooc_week2-2_信号报告

题目内容:无线电台的RS制信号报告是由三两个部分组成的:R(Readability) 信号可辨度即清晰度.S(Strength)    信号强度即大小.其中R位于报告第一位,共分5级,用1—5数字表示.UnreadableBarely readable, occasional words distinguishableReadable with considerable difficultyRea...

mjc29788的博客 244

浙大Mooc_week2-1_时间换算

1时间换算(5分)题目内容:UTC是世界协调时,BJT是北京时间,UTC时间相当于BJT减去8。现在,你的程序要读入一个整数,表示BJT的时和分。整数的个位和十位表示分,百位和千位表示小时。如果小时小于10,则没有千位部分;如果小时是0,则没有百位部分;如果小时不是0而分小于10分,需要保留十位上的0;如果小时是0而分小于10分的,则不需要保留十位上的0。如1124表示11点24分,而905表示9...

mjc29788的博客 382

浙大Mooc_week4-2_念整数

题目内容:你的程序要读入一个整数,范围是[-100000,100000]。然后,用汉语拼音将这个整数的每一位输出出来。如输入1234,则输出:yi er san si注意,每个字的拼音之间有一个空格,但是最后的字后面没有空格。当遇到负数时,在输出的开头加上“fu”,如-2341输出为:fu er san si yi输入格式:一个整数,范围是[-100000,100000]。输出格式:表示这个整数的...

mjc29788的博客 427

浙大Mooc_week3-2_数字特征值

题目内容:对数字求特征值是常用的编码算法,奇偶特征是一种简单的特征值。对于一个整数,从个位开始对每一位数字编号,个位是1号,十位是2号,以此类推。这个整数在第n位上的数字记作x,如果x和n的奇偶性相同,则记下一个1,否则记下一个0。按照整数的顺序把对应位的表示奇偶性的0和1都记录下来,就形成了一个二进制数字。比如,对于342315,这个二进制数字就是001101。这里的计算可以用下面的表格来表示:...

mjc29788的博客 859

浙大Mooc_week1_逆序的三位数

题目内容:逆序的三位数:程序每次读入一个正三位数,然后输出逆序的数字。注意,当输入的数字含有结尾的0时,输出不应带有前导的0。比如输入700,输出应该是7。提示:用%10可以得到个位数,用/100可以得到百位数...。将这样得到的三个数字合起来:百位*100+十位*10+个位,就得到了结果。注意:除了题目要求的输出,不能输出任何其他内容,比如输入时的提示,输出时的说明等等都不能。这道题目要求输出逆...

mjc29788的博客 322
上一篇: 数据结构——浙大版中国大学mooc(week3)
下一篇: 数据结构——浙大版中国大学mooc(week1)
CodingW
博客等级 码龄8年 3粉丝 16原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值