作业11

最新推荐文章于 2022-01-19 11:51:09 发布
最新推荐文章于 2022-01-19 11:51:09 发布
阅读量133 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43270082/article/details/97814408
版权

1、题目：利用链表实现一个先入后出的栈结构,并提供栈操作的push和pop的接口

/*****************************************************
copyright (C), 2014-2015, Lighting Studio. Co.,     Ltd. 
File name：
Author：Jerey_Jobs    Version:0.1    Date: 
Description：
Funcion List: 
*****************************************************/

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

typedef struct node Node;
typedef struct node * Link;

struct node
{
    int num;

    Link next;
};

void creat_node(Link *node)
{
    *node = (Link)malloc(sizeof(Node));

    if(*node == NULL)
    {
        printf("malloc error!\n");

        exit(-1);
    }
}

void creat_link(Link *head)
{
    creat_node(head);
    (*head)->next = NULL;
}

void incret_node(Link head,Link new_node)
{
    Link p;
    p = p->next;

    if(head->next == NULL)
    {
        new_node->next = head->next;
        head->next = new_node;
        printf("push ok!\n");
    }
    else
    {
        new_node->next = head->next;
        head->next = new_node;
        printf("push ok!\n");

    }
}

void display_node(Link *head)
{
    if((*head)->next == NULL)
    {
        printf("zhan is empty!\n");
        return;
    }

    while((*head)->next != NULL)
    {
        printf("pop = %d\n",(*head)->next->num);
        (*head)->next = (*head)->next->next;
    }
}

int main()
{
    Link head;
    Link new_node;
    int i,n;

    creat_link(&head);

    srand(time(NULL));

    printf("Please the number of number you want to input:");
    scanf("%d",&n);
    for(i = 0; i < n; i++)
    {
        creat_node(&new_node);

        new_node->num = rand() % 100;

        incret_node(head,new_node);
    }

    display_node(&head);

    display_node(&head);

    return 0;
}

结果：
在这里插入图片描述
2、题目：使用双向链表来实现双向队列
使用一个双向链表来实现一个双向的队列，并且让队列具有以下的操作：

（1）判断队列是否为空

（2）得到双向队列中元素的个数

（3）向左端添加一个新元素

（4）向右端添加一个新元素

（5）从左端删除一个元素

（6）从右端删除一个元素

/*****************************************************
copyright (C), 2014-2015, Lighting Studio. Co.,     Ltd. 
File name：
Author：Jerey_Jobs    Version:0.1    Date: 
Description：
Funcion List: 
*****************************************************/

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

typedef struct node Node;
typedef struct node * Link;

struct node 
{
    int num;
    Link next;
    Link prior;
};

void creat_node(Link *node)
{
    *node = (Link)malloc(sizeof(Node));

    if(*node == NULL)
    {
        printf("malloc error!\n");

        exit(-1);
    }
}

void creat_link(Link *head)
{
    creat_node(head);

    (*head)->next = *head;
    (*head)->prior = *head;
}

void incret_node(Link head,Link new_node)
{
    if(head == NULL)
    {
        printf("que empty!\n");
    }

    new_node->prior = head->prior;
    new_node->next = head;
    head->prior = new_node;
    new_node->prior->next = new_node;
    
}

void incret_left(Link head,Link new_node)
{
    if(head == NULL)
    {
        printf("the que is empty!\n");
        return;
    }

    new_node->next = head->next;
    new_node->prior = head;
    head->next = new_node;
    new_node->next->prior = new_node;
}

void incret_right(Link head,Link new_node)
{
    if(head == NULL)
    {
        printf("the que is empty!\n");
        return;
    }

    new_node->next = head;
    new_node->prior = head->prior;
    head->prior->next = new_node;
    head->prior = new_node;
}

void delet_left(Link head)
{
    Link p;
    p = head->next;
    if(head == NULL)
    {
        printf("the que is empty!\n");
        return;
    }

    p->prior->next = p->next;
    p->next->prior = p->prior;
}

void delet_right(Link head)
{
    Link p;
    p = head->prior;

    p->prior->next = p->next;
    p->next->prior = p->prior;
}

void display_que(Link *head)
{
    Link p,q;
    int i = 0;
    if(*head == NULL)
    {
        printf("que empty!\n");
        return;
    }

    if((*head)->next == *head)
    {
        printf("que empty!\n");
        return;
    }

    p = (*head)->next;
    while((*head)->next != *head)
    {
        p = (*head)->next;
        i++;
        printf("%3d",p->num);
        free(p);
        (*head)->next = (*head)->next->next;
    }
    (*head)->prior = *head;
    printf("\n");
    printf("the number of words:%3d\n",i);
}

int main()
{
    Link head;
    Link new_node;

    int i,n,m,t;
    int g,k;

    creat_link(&head);
    srand(time(NULL));

    printf("How many number you want to input:");
    scanf("%d",&n);

    for(i = 0; i < n; i++)
    {
        creat_node(&new_node);
        new_node->num = rand() % 100;
        printf("%3d",new_node->num);
        incret_node(head,new_node);
    }
    printf("\n");
    printf("the number of the words:%3d\n",n);

    //display_que(&head);

    printf("Please input the number you want to incret the left:");
    scanf("%d",&m);
    creat_node(&new_node);
    new_node->num = m;
    incret_left(head,new_node);

    printf("Please input the number you want to incret the right:");
    scanf("%d",&t);
    creat_node(&new_node);
    new_node->num = t;
    incret_right(head,new_node);

    display_que(&head);

    printf("\n");
    for(i = 0; i < n; i++)
    {
        creat_node(&new_node);
        new_node->num = rand() % 100;
        printf("%3d",new_node->num);
        incret_node(head,new_node);
    }
    printf("\n");
    printf("Delet left and ringht:\n");

    delet_left(head);
    delet_right(head);

    display_que(&head);

    return 0;
}

结果：
在这里插入图片描述

3、题目：通过链栈实现的简易计算器

/*****************************************************
copyright (C), 2014-2015, Lighting Studio. Co.,     Ltd. 
File name：
Author：Jerey_Jobs    Version:0.1    Date: 
Description：
Funcion List: 
*****************************************************/

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

#define Max 100

struct node1
{
    int data[Max];
    
    int top;
};

struct node2
{
    char data[Max];

    int top;
};

typedef struct node1 Num;
typedef struct node2 Ch;

void init_stract1(Num *stract1)
{
    stract1->top = -1;
}

void init_stract2(Ch *stract2)
{
    stract2->top = -1;
}

int empty_stract1(Num *stract1)
{
    if(stract1->top == -1)
    {
        return -1;
    }

    return 0;
}

int empty_stract2(Ch *stract2)
{
    if(stract2->top == -1)
    {
        return -1;
    }

    return 0;
}

char get_stract2(Ch *stract2)
{
    if(empty_stract2(stract2) == -1)
    {
        return -1;
    }

    return stract2->data[stract2->top];
}

void incret_stract1(Num *stract1,int num)
{
    stract1->top++;
    stract1->data[stract1->top] = num;
    printf("push:%d\n",stract1->data[stract1->top]);
}

void incret_stract2(Ch *stract2,char str)
{
    stract2->top++;
    stract2->data[stract2->top] = str;
}

int get_priority(char ch)
{
    if(ch == '+' || ch == '-')
    {
        return 1;
    }

    if(ch == '*' || ch == '/')
    {
        return 2;
    }

}

int compare_priority(char ch,char str)
{
    if(get_priority(ch) >= get_priority(str))
    {
        return 1;
    }

    return -1;
}

int push_stract1(Num *stract1)
{
    if(empty_stract1(stract1) == -1)
    {
        return -1;
    }

    int num;
    num = stract1->data[stract1->top];

    stract1->top--;

    return num;
}

char push_stract2(Ch *stract2)
{
    if(empty_stract2(stract2) == -1)
    {
        return -1;
    }

    char ch;

    ch = stract2->data[stract2->top];
    stract2->top--;
    return ch;
}

int count(int a,int b,char ch)
{
    int rel;
    switch(ch)
    {
        case '+':
            {
                rel = a + b;
                break;
            }

        case '-':
            {
                rel =  a - b;
                break;
            }

        case '*':
            {
                rel =  a * b;
                break;
            }

        case '/':
            {
                rel =  a / b;
                break;
            }
    }

    return rel;
}

int main()
{
    Num *stract1;
    Ch *stract2;
    char str;
    int i = 0;
    int num;
    char ch;
    int a,b;
    int rel;

    stract1 = (Num *)malloc(sizeof(Num));
    stract2 = (Ch *)malloc(sizeof(Ch));

    init_stract1(stract1);
    init_stract2(stract2);

    while((str = getchar()) != '\n')
    {
        if(str >= '0' && str <= '9')
        {
            num = str - '0';
            incret_stract1(stract1,num);
        }
        else
        {
            if(str == '+' || str == '-' || str == '*' || str == '/')
            {
                do{
                    ch = get_stract2(stract2);

                    if(ch == -1)
                    {
                        incret_stract2(stract2,str);
                        break;
                    }
                    else
                    {
                        if(compare_priority(ch,str) < 0)
                        {
                            incret_stract2(stract2,str);
                            break;
                        }
                        else
                        {
                            a = push_stract1(stract1);
                            b = push_stract1(stract1);
                            ch = push_stract2(stract2);

                            if(a == -1 || b == -1 || ch == -1)
                            {
                                printf("all is empty!\n");
                            }

                            rel = count(b,a,ch);
                            incret_stract1(stract1,rel);
                        }
                    }
                }while(compare_priority(ch,str) > 0);
            }
        }
    }

    while(empty_stract1(stract1) != -1 && empty_stract2(stract2) != -1)
    {
        a = push_stract1(stract1);
        b = push_stract1(stract1);
        ch = push_stract2(stract2);

        rel = count(b,a,ch);
        incret_stract1(stract1,rel);
    }

    printf("reasult = %d\n",rel);

    free(stract1);
    free(stract2);

    return 0;
}

结果：
在这里插入图片描述
4、题目：利用两个栈来模拟一个队列
利用两个栈S1,S2来模拟一个队列，已知栈的4个运算定义如下：
Push(S,x); //元素x入栈S
Pop(S,x); //S出栈并将出栈的值赋给x
StackEmpty(S); //判断栈是否为空
StackOverflow(S); //判断栈是否满
那么如何利用栈的运算来实现该队列的3个运算(形参由读者根据要求自己设计)：
Enqueue; //将元素x入队
Dequeue; //出队，并将出队元素存储在x中
QueueEmpty; //判断队列是否为空

/*****************************************************
copyright (C), 2014-2015, Lighting Studio. Co.,     Ltd. 
File name：
Author：Jerey_Jobs    Version:0.1    Date: 
Description：
Funcion List: 
*****************************************************/

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

#define Max 100


struct stract
{
    int stract[Max];

    int top;
};

typedef struct stract Stract;

enum ptr {PUSH_OK,PUSH_NO,POP_OK,POP_NO,EMPTY_OK,EMPTY_NO};

void creat_stract(Stract *stract)
{
    stract->top = -1;
}

void creat_(Stract **stract)
{
    (*stract) = (Stract *)malloc(sizeof(Stract));

    if((*stract) == NULL)
    {
        printf("malloc error!\n");
        exit(-1);
    }
}

int incret_stract(Stract *stract,int k)
{
    if(stract->top != Max - 1)
    {
        stract->top++;
        stract->stract[stract->top] = k;
        return PUSH_OK;
    }
    else
    {
        return PUSH_NO;
    }
}

int output(Stract *stract)
{
    if(stract->top == -1)
    {
        return EMPTY_OK;
    }
    else
    {
        return stract->stract[stract->top--];
    }
}

int main()
{
    Stract *stract1;
    Stract *stract2;
    int i,n,ret,k;

    creat_(&stract1);
    creat_(&stract2);

    creat_stract(stract1);
    creat_stract(stract2);

    srand(time(NULL));

    printf("Please how many number you want to input:");
    scanf("%d",&n);

    for(i = 0; i < n; i++)
    {
        k = rand() % 100;
        printf("%3d",k);

        if(incret_stract(stract1,k) == PUSH_OK)
        {
            printf("push ok!");
        }
        else
        {
            printf("push no!");
            break;
        }
        printf("\n");
    }

    for(i = 0; i < n; i++)
    {
        ret = output(stract1);

        if(ret == EMPTY_OK)
        {
            printf("empty ok\n");
            break;
        }
        else
        {
            incret_stract(stract2,ret);
        }
    }

    for(i = 0; i < n; i++)
    {
        ret = output(stract2);

        if(ret == EMPTY_OK)
        {
            printf("empty ok!\n");
            break;
        }
        else
        {
            printf("%3d\n",ret);
        }
    }


    return 0;
}

结果：
在这里插入图片描述

5、题目：假设称正读和反读都相同的字符序列为“回文”，例如，‘abba‘ 和 ‘abcba‘是回文，
‘abcde‘ 和 ‘ababab‘ 则不是回文。试写一个算法判别读入的一个以‘@‘为结束符的字符序列是否是“回文”。
（栈和队列）

/*****************************************************
copyright (C), 2014-2015, Lighting Studio. Co.,     Ltd. 
File name：
Author：Jerey_Jobs    Version:0.1    Date: 
Description：
Funcion List: 
*****************************************************/

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

typedef struct node Node;
typedef struct node * Link;

struct node
{
    char op_ch;

    Link next;
};

void creat_node(Link *node)
{
    *node = (Link)malloc(sizeof(Node));

    if(*node == NULL)
    {
        printf("malloc error!\n");
        exit(-1);
    }
}

void creat_link(Link *head)
{
    creat_node(head);

    (*head)->next = NULL;
}

void incret_zhan(Link head,Link new_node)
{
    if(head == NULL)
    {
        printf("zhan is empty!\n");
        return;
    }

    new_node->next = head->next;
    head->next = new_node;
}

void incret_que(Link head,Link new_node)
{
    if(head == NULL)
    {
        printf("que is empty!\n");
        return;
    }

    Link p;

    if(head->next == NULL)
    {
        new_node->next = head->next;
        head->next = new_node;
    }
    else
    {
        p = head->next;

        while(p->next != NULL)
        {
            p = p->next;
        }

        new_node->next = p->next;
        p->next = new_node;
    }
}

void display(Link *head1,Link *head2)
{
    if(*head1 == NULL && *head2 == NULL)
    {
        printf("all is empty!\n");
        return;
    }
    
    if((*head1)->next == NULL && (*head2)->next == NULL)
    {
        printf("all is empty!\n");
        return;
    }

    Link p = NULL,q = NULL;

    int i = 0;
    char a[100],b[100];

    while((*head1)->next != NULL)
    {
        p = (*head1)->next;
        a[i++] = p->op_ch;
        (*head1)->next = p->next;
        free(p);
    }
    a[i] = '\0';

    i = 0;
    
    while((*head2)->next != NULL)
    {
        q = (*head2)->next;
        b[i] = (*head2)->next->op_ch;
        (*head2)->next = q->next;
        free(q);
        i++;
    }
    b[i] = '\0';

    if(strcmp(a,b) == 0)
    {
        printf("yes\n");
    }
    else
    {
        printf("no\n");
    }
}

int main()
{
    Link head1;
    Link head2;
    Link new_node1;
    Link new_node2;
    char str[100];
    int i = 0;

    gets(str);

    creat_link(&head1);
    creat_link(&head2);

    while(str[i] != '\0')
    {
        if(str[i] == '@')
        {
            i++;
            display(&head1,&head2);
        }

        creat_node(&new_node1);
        creat_node(&new_node2);
        new_node1->op_ch = str[i];
        new_node2->op_ch = str[i];
        incret_zhan(head1,new_node1);
        incret_que(head2,new_node2);
        i++;
    }
    display(&head1,&head2);

    return 0;
}

结果：
在这里插入图片描述

傍晚！
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
使用栈模拟队列操作
01-15 301
问题描述 利用两个栈S1，S2来模拟一个队列，已知栈的4的运算定义如下： Push(S,x); 元素x入栈S  Pop(S,x); S出栈并将出栈的值赋给x  StackEmpty(S); 判断栈是否为空  StackOverflow(S); 判断栈是否满 Enqueue; 将元素x入队  Dequeue; 出队，并将出队元素存储在x中  QueueEmpty;
队列相关习题及详解(选择题和综合题) ——数据结构
热门推荐
Amour
10-31 3万+
队列的基本概念队列的定义队列（Queue）：队列简称队，也是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除。向队列中插入元素称为入队或进队；删除元素称为出队或离队。这和我们日常生活中的排队是一致的，最早排队的也是最早离队的。其操作的特性是先进先出（First In First Out, FIFO），故又称为先进先出的线性表。队头（Front）：允许删除的一端，又称为首队 队
西北工业大学NOJ Python程序设计作业11-20
Phoenix_ZengHao的博客
01-19 6638
第2季：小段代码(Season 2-Snippet) （11-20） 前置知识点 建议大概了解下述函数库的基本运用之后再完成题目会更顺利。 math库 导入函数库import math 求余切：math.atan()的输入参数是弧度而不是度。 求平方根：math.sqrt() 求次方： math.pow(x,y)相当于求xyx^yxy 求反余弦值：math.acos() fractions库 可以同时提供分子（numerator）和分母（denominator）给构造函数用于实例化Fraction类，
作业十一
kjhmh2的博客
12-24 300
虚拟按键小游戏图片识别与建模虚拟按键的使用 图片识别与建模 首先，我们在vuforia网站上进行注册登录，然后创建证书，用于获取License Key： 创建目标数据库,用于对所有Target及其特征数据进行管理和保存。然后我们选择一副图片，进行特征识别： 此处，可以看见识别之后给该图片打分是五颗星，说明识别效果比较不错。 然后创建Unity新项目,并开启Vuforia AR 支持: 在...
作业11.zip
04-12
【标题】"作业11.zip"的解析与相关知识点 在信息技术领域，文件压缩是一种常见的数据处理技术，用于减小文件占用的存储空间。"作业11.zip"是一个压缩文件，很可能包含了多个相关的作业文件，比如文档、图像、代码或...
作业11.rar
11-03
【标题】"作业11.rar"可能是一个包含一系列学习材料或任务的压缩文件，通常在教育环境中使用，用于分发或提交作业。由于没有提供具体的标签，我们可以假设这个压缩包可能包含了与某个课程主题相关的各种文件，比如...
黑箱建模作业11
08-08
黑箱建模作业11 黑箱建模是一种常见的数据分析方法，用于研究变量之间的关系。黑箱建模作业11的主要目标是分析矿石中成分A和成分B的含量之间是否存在线性关系。 首先，让我们来了解什么是线性关系。线性关系是指...
人工智能作业11
08-03
"人工智能作业11知识点总结" 人工智能是一门多disciplinary领域，涉及计算机科学、数学、工程学、哲学、认知科学、神经科学等多个领域。以下是人工智能作业11的知识点总结： 一、人工智能的定义和历史发展： 人工...
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不会在编写
Android学习系列之gradle实战
07-23
Android学习系列之gradle实战
RFC 3261中文版技术文档
07-23
**标题与描述解析** 标题"RFC 3261 中文文档"指的是互联网请求评论（Request for Comments）3261的中文版本。RFC 3261是互联网工程任务组（IETF）发布的一个重要标准，它定义了SIP（Session Initiation Protocol，会话初始协议）的核心规范。SIP是一种用于建立、修改和终止多媒体通信会话的协议，广泛应用于VoIP（Voice over IP，IP语音）和统一通信系统中。 描述同样简洁明了，只强调了这是RFC 3261的中文翻译，意味着对于中文读者来说，这个文档提供了一个理解SIP协议的中文语言资源。 **标签解析** "RFC3261 中文"标签进一步确认了文档的内容，表明这是关于RFC 3261的中文资料，便于搜索和分类。 **压缩包子文件的文件名称列表** 文件名为"RFC3261 中文.mht"，这是一个单一网页文件，通常包含HTML、图像和其他资源，用于保存完整的网页内容。用户可以通过打开这个文件来查看RFC 3261的中文翻译。 **SIP协议详述** SIP协议是基于文本的，其设计类似于HTTP
嵌入式LinuxC语言程序设计基础教程第8章函数解读.doc
07-23
嵌入式
DirectShow滤镜：字幕叠加功能（含注解说明）
07-23
DirectShow Transform Filter最典型的例子，带注释，难度不大，学习必备 博客对应文章http://blog.csdn.net/leixiaohua1020/article/details/12498975。内容来源于网络分享，如有侵权请联系我删除。另外如果没有积分的同学需要下载，请私信我。
b069牙科就诊管理系统-springboot+vue+elementui.zip（可运行源码+sql文件+文档）
07-23
牙科就诊管理系统利用当下成熟完善的SSM框架，使用跨平台的可开发大型商业网站的Java语言，以及最受欢迎的RDBMS应用软件之一的Mysql数据库进行程序开发。实现了用户在线查看数据。管理员管理病例管理、字典管理、公告管理、药单管理、药品管理、药品收藏管理、药品评价管理、药品订单管理、牙医管理、牙医收藏管理、牙医评价管理、牙医挂号管理、用户管理、管理员管理等功能。牙科就诊管理系统的开发根据操作人员需要设计的界面简洁美观，在功能模块布局上跟同类型网站保持一致，程序在实现基本要求功能时，也为数据信息面临的安全问题提供了一些实用的解决方案。可以说该程序在帮助管理者高效率地处理工作事务的同时，也实现了数据信息的整体化，规范化与自动化。 管理员在后台主要管理病例管理、字典管理、公告管理、药单管理、药品管理、药品收藏管理、药品评价管理、药品订单管理、牙医管理、牙医收藏管理、牙医评价管理、牙医挂号管理、用户管理、管理员管理等。 牙医列表页面，此页面提供给管理员的功能有：查看牙医、新增牙医、修改牙医、删除牙医等。公告信息管理页面提供的功能操作有：新增公告，修改公告，删除公告操作。公告类型管理页面显示所有公告类型，在此页面既可以让管理员添加新的公告信息类型，也能对已有的公告类型信息执行编辑更新，失效的公告类型信息也能让管理员快速删除。药品管理页面，此页面提供给管理员的功能有：新增药品,修改药品,删除药品。药品类型管理页面，此页面提供给管理员的功能有：新增药品类型,修改药品类型,删除药品类型。
"【实验报告】作业11：引入动量因素的参数更新方法在物理学中的应用
【实验报告】作业11；引入了物理学中动量因素，从而可以使得参数在梯度非常大的地方更新的非常快，并且也能使 loss 避免陷入局部最小值和鞍点，更容易到达全局最小值5. 数据集和验证集;《人工智能》实验报告 学号： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值