程序员经验分享-hwhale

数据结构--单链表的c语言实现（超详细注释/实验报告）

2023-11-17

数据结构–单链表的c语言实现（超详细注释/实验报告）

知识小回顾

在顺序表中，用一组地址连续的存储单元来一次存放线性表的结点，因此结点的逻辑顺序和物理顺序是一致的。而链表则不然，链表是用一组任意的存储单元来存放线性表的结点，这组储存单元可以是连续的，也可以是非连续的，甚至是零散分布在内存的任何位置上。因此链表中结点的逻辑顺序和物理顺序不一定相同。为了正确地表示结点间的逻辑关系，必须存储线性表的每个数据元素值的同时，存储知识其后继结点的地址（位置）信息，这两部分信息组成的存储映像成为结点（Node）。

实验题目

实现单链表表各种基本运算

实验目的

  1. 熟悉将算法转换为程序代码的过程；
  2. 熟练掌握顺序表的基本运算：头插法建表、尾插法建表、按序号查找、按值查找、求表长度、插入元素、删除指定元素等。

实验要求

  1. 以单链表表作为存储结构；
  2. 实现单链表上的数据元素的头插法建表、尾插法建表、按序号查找、按值查找、求表长度、插入元素、删除指定元素等操作。

实验内容和实验步骤

1）需求分析

以菜单的形式作为用户与程序的接口，用户输入菜单号来实行相应的操作。

2）概要设计

设计几个函数来实现初始化、头插法建表、尾插法建表、按序号查找、按值查找、求表长度、插入元素和删除指定元素的功能，然后再主函数中调用函数来实现操作。

3）详细设计

导入相关的库

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

单链表的存储结构。
注意：LinkList 和 Node * 同为结构体指针类型，这两种类型是等价的。
通常习惯上用LinkList说明指针变量，强调它是某个单链表的头指针变量。
such as 使用定义LinkList L，则L为单链表的头指针，从而提高程序的可读性。
使用Node * 来定义只想单链表中节点的指针，例如，Node *p,则p为指向单链表中节点的指针变量。

typedef int ElemType;
typedef struct Node
{
    ElemType data;
    struct Node * next;
}Node,* LinkList;
/*LinkList 和 Node * 同为结构体指针类型，这两种类型是等价的。
通常习惯上用LinkList说明指针变量，强调它是某个单链表的头指针变量。
such as 使用定义LinkList L，则L为单链表的头指针，从而提高程序的可读性。
使用Node * 来定义只想单链表中节点的指针，例如，Node *p,则p为指向单链表中节点的指针变量。*/

初始化单链表

//初始化单链表
void Init_LinkList(LinkList *L)
{
    *L=(LinkList)malloc(sizeof(Node));//建立头结点
    (*L)->next=NULL;//建立空的单链表
    //注意：L是指向单链表头结点的指针，用来接收主程序中带初始化单链表的头指针变量的地址，
    //*L相当于主程序中带初始化单链表的头指针变量。
}

头插法建表（逆序建表法）
算法思想：从一个空表开始，每次读入数据，生成新结点，将读入数据存放到新结点的数据域中，然后将新节点插入到当前链表的表头结点之后，直至读入结束标志为止。

//用头插法建立单链表
void CreateFromHead(LinkList L)
{
    //L是带头结点的空链表头指针，通过键盘输入表中个元素值，利用头插法建单链表L
    Node *s;//s为只想单链表中结点的指针变量
    char c;
    int flag=1;
    while(flag)
    {
        c=getchar();
        if(c!='$')
        {
            s=(Node *)malloc(sizeof(Node));//建立新的结点
            s->data=(int)c;//给s赋值
            s->next=L->next;//把s变成头结点的后一个，后面的话，新的s都是L的后一个，这样也就导致了逻辑顺序和输入元素顺序相反
            L->next=s;
        }
        else flag=0;
    }
}

尾插法建表（顺序）
算法思想：将新节点插到前单链表的表尾上。为此需要增加一个尾指针r，使之只想当前单链表的表尾。

//尾插法建表
void CreateFromTail(LinkList L)
{
    Node *r,*s;//一个动态的尾指针r
    int flag=1;
    r=L;
    char c;
    while(flag)
    {
        c=getchar();
       // printf(" ");
        if(c!='$')
        {
            s=(Node*)malloc(sizeof(Node));
            s->data=(int)c;
            r->next=s;
            r=s;//r始终是在最后的
        }
        else
        {
            flag=0;
            r->next=NULL;//将最后一个结点的next链域设为空，表示链表的结束
        }
    }
}

按序号查找元素。
算法思想：在单链表中，由于每个系欸但的存储位置都放在其前一结点的next域中，所以即使知道被访问结点的序号i，也不能像顺序表那样直接按序号i访问以为数组中的相应元素，实现随机存取，而只能从来链表的头指针出发，顺链域next逐个结点往下搜索，直至搜索到第i个结点为止。

//在单链表L中查找第i个结点
Node* Get(LinkList L,int i)
{
    int j;
    Node *p;
    if(i<0)
        return NULL;
    p=L;
    j=0;//j是一个计数器，用来与i比较
    while((p->next!=NULL)&&(j<i))//判断条件为：到达表尾或等于要查找的结点
    {
        p=p->next;
        j++;
    }
    if(i==j)
        return p;
    else
        return NULL;
}

按值查找元素。
算法思想：从单链表的头指针指向的头结点出发，顺链逐个将结点值和给定值 e e e作比较，打印出查找结果。

//在单链表中查找值为x的结点
int Locate(LinkList L,int x)
{
    LinkList p;
    int j=1;
    p=L->next;
    while(p!=NULL&&p->data!=x)
    {
        p=p->next;
        j++;
    }
    if(p)
    {
        printf("%d在链表中，是第%d个元素",p->data-48,j);//由于是ascii，所以-48
    }
    else
    {
        printf("该数值不在链表里。\n");
        return 0;
    }
}

求单链表的长度。
算法思想：采用“数结点”的方法求出带头结点单链表的长度。即从“头”开始“数”（p=l->next）,用指针p依次指向各个结点，并附设计数器j技术，一直“数"到最后一个结点（p->next==NULL），从而得到单链表的长度。

//求单链表的长度
int ListLength(LinkList L)
{
    Node *p;
    p=L->next;
    int j=0;//计数器j
    while(p!=NULL)
    {
        p=p->next;
        j++;
    }
    printf("%d",j);
    return 0;
}

单链表插入操作。
算法思想：

  1. 查找：在单链表中找到第i-1个结点，并由指针p表示。
  2. 申请：申请新结点s，将其数值域的值置为e。
  3. 插入：尾插法插入。
//单链表插入操作
int Insert_LinkList(LinkList L,int i,char x)
{
    Node *p,*s;
    p=Get(L,i-1);//这是一个小细节，如果设为i的话就不能实现在第1个元素前面插入的操作了
    if(p==NULL)
    {
        printf("参数i输入有误！\n");
        return 0;
    }
    else
    {
        //其实就是尾插法
        s=(Node *)malloc(sizeof(Node));
        s->data=x;
        s->next=p->next;
        p->next=s;
        return 1;
    }
}

单链表删除操作。
算法思想：

  1. 查找：通过计数方式找到第i-1个基点，并由pre指示。
  2. 删除第i个结点并释放空间。
//单链表删除操作
int Delete_LinkList(LinkList L,int i)
{
    //在带头结点的单链表L中删除第i个元素
    Node *pre,*r;
    int k;
    pre=L;k=0;
    while(pre->next!=NULL&&k<i-1)
    {
        pre=pre->next;
        k++;
    }
    if(pre->next==NULL)
    {
        printf("删除结点的位置i不合理!\n");
        return 0;
    }
    r=pre->next;//r指向要删除的第i个结点
    pre->next=r->next;//第i个结点前的结点的后一个结点变成第i个结点后一个结点
    free(r);//释放r
    return 1;
}

显示单链表。
算法思想：顺着指针一个一个地打印。

//display单链表
void Display_LinkList(LinkList L)
{
    //printf("display调用开始\n");
    Node *p;
    ElemType s;
    p=L;
    while(p->next)
    {
        //p=p->next;
        printf("%c  ",p->next->data);//由于前面是getchar（），所以%c
        //printf("  ");
        p=p->next;
    }
    //printf("display调用结束\n");
}

主函数，用一种“菜单”的形式使单链表的操作更加地清晰地展示出来。
主函数1
主函数2

int main()
{


    LinkList L;
    ElemType e,x;
    int i=1,k,j;
    Init_LinkList(&L);
    printf("尾插法建立单链表如下：\n(输入规则：一个数字一个数字地输入，不用加空格和回车，空格和回车也会被当作是一个字符，结束的时候请输入'$')\n");
    CreateFromTail(&L);
    system("cls");//清屏
    while(i)//保证一直进行
    {
        printf("\n现在的链表:  ");
        Display_LinkList(&L);
        printf("\n-------------------------------------\n");
        printf("             Main Menu         \n");
        printf("    1   在单链表中查找第i个结点    \n");
        printf("    2   在单链表中查找值为key的结点   \n");
        printf("    3   求单链表的长度   \n");
        printf("    4   单链表插入(在第i个结点插入e)   \n");
        printf("    5   单链表删除操作   \n");
        printf("    6   清屏   \n");
        printf("    0   结束程序      \n");
        printf("--------------------------------------\n");
        printf("请输入你选择的菜单号<1, 2, 3, 4, 5, 6, 0>:\n");
        scanf("%d",&i);
        switch(i)
        {
        case 1:
            printf("请输入要查找的结点：");
            scanf("%d",&x);
            Node *p1;
            p1=Get(&L,x);
            //printf("%d",p1->data-48);
            printf(p1);
            printf("\n");
            break;
        case 2:
            printf("请输入要查找的值x：");
            scanf("%d",&x);
            Locate(&L,x+48);
            printf("\n\n");
            break;
        case 3:
            printf("长度为");
            //ListLength(&L);
            int p3=ListLength(&L);
            //printf(ListLength(&L));
            //Display_LinkList(&L);
            //printf("%d",p3);
            printf("\n\n");
            break;
        case 4:
            printf("要插入到哪个结点前？\n");
            int i;
            scanf("%d",&i);
            //ElemType e;
            int e;
            printf("要插入哪个值呢？\n");
            scanf("%s",&e);
            Insert_LinkList(&L,i,e);
            printf("\n\n");
            break;
        case 5:
            printf("要删除到哪个结点呢？\n");
            int ii;
            scanf("%d",&ii);
            ElemType ee;
            Delete_LinkList(&L,ii);
            //Display_LinkList(&L);
            printf("\n\n");
            break;
        case 6:
            system("cls");
            break;
        case 0:
                exit(0);
                break;
        default:
            printf("输入有误~");
        }
    }
return 0;
}

4）调试分析

遇到的问题及解决方法
  • 有很多细节需要好好琢磨和调试
算法的时空分析
  • 都是比较基础的操作，没有涉及很复杂的算法，故时空复杂度也还不算很大。
实验结果

实验结果很不错，所有操作都能正常执行，并且自己加入了“清屏”选项，使得界面更加的整洁。

实验总结

这是第二个数据结构的代码实现，这一次就没有直接照着实验指导敲了，是结合教材和实验指导以及同学的代码写出来的，这次写完之后收获很大！多多重复，百炼成钢！

最后附上完整的代码

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
//用typedef 给int定义个名字为ElemType，意思是表中元素的type
typedef int ElemType;
typedef struct Node
{
    ElemType data;
    struct Node * next;
}Node,* LinkList;
/*LinkList 和 Node * 同为结构体指针类型，这两种类型是等价的
。通常习惯上用LinkList说明指针变量，强调它是某个单链表的头
指针变量。such as 使用定义LinkList L，则L为单链表的头指针，从而提高程序的可读性。
使用Node * 来定义只想单链表中节点的指针，例如，Node *p,则p为指向单链表中节点的指针变量。*/

//初始化单链表
void Init_LinkList(LinkList *L)
{
    *L=(LinkList)malloc(sizeof(Node));//建立头结点
    (*L)->next=NULL;//建立空的单链表
    //注意：L是指向单链表头结点的指针，用来接收主程序中带初始化单链表的头指针变量的地址，
    //*L相当于主程序中带初始化单链表的头指针变量。
}

//用头插法建立单链表
void CreateFromHead(LinkList L)
{
    //L是带头结点的空链表头指针，通过键盘输入表中个元素值，利用头插法建单链表L
    Node *s;//s为只想单链表中结点的指针变量
    char c;
    int flag=1;
    while(flag)
    {
        c=getchar();
        if(c!='$')
        {
            s=(Node *)malloc(sizeof(Node));//建立新的结点
            s->data=(int)c;//给s赋值
            s->next=L->next;//把s变成头结点的后一个，后面的话，新的s都是L的后一个，这样也就导致了逻辑顺序和输入元素顺序相反
            L->next=s;
        }
        else flag=0;
    }
}

//尾插法建表
void CreateFromTail(LinkList L)
{
    Node *r,*s;//一个动态的尾指针r
    int flag=1;
    r=L;
    char c;
    while(flag)
    {
        c=getchar();
       // printf(" ");
        if(c!='$')
        {
            s=(Node*)malloc(sizeof(Node));
            s->data=(int)c;
            r->next=s;
            r=s;//r始终是在最后的
        }
        else
        {
            flag=0;
            r->next=NULL;//将最后一个结点的next链域设为空，表示链表的结束
        }
    }
}

//在单链表L中查找第i个结点
Node* Get(LinkList L,int i)
{
    int j;
    Node *p;
    if(i<0)
        return NULL;
    p=L;
    j=0;//j是一个计数器，用来与i比较
    while((p->next!=NULL)&&(j<i))//判断条件为：到达表尾或等于要查找的结点
    {
        p=p->next;
        j++;
    }
    if(i==j)
        return p;
    else
        return NULL;
}

//在单链表中查找值为x的结点
int Locate(LinkList L,int x)
{
    LinkList p;
    int j=1;
    p=L->next;
    while(p!=NULL&&p->data!=x)
    {
        p=p->next;
        j++;
    }
    if(p)
    {
        printf("%d在链表中，是第%d个元素",p->data-48,j);//由于是ascii，所以-48
    }
    else
    {
        printf("该数值不在链表里。\n");
        return 0;
    }
}

//求单链表的长度
int ListLength(LinkList L)
{
    Node *p;
    p=L->next;
    int j=0;//计数器j
    while(p!=NULL)
    {
        p=p->next;
        j++;
    }
    printf("%d",j);
    return 0;
}

int Insert_LinkList(LinkList L,int i,char x)
{
    Node *p,*s;
    p=Get(L,i-1);//这是一个小细节，如果设为i的话就不能实现在第1个元素前面插入的操作了
    if(p==NULL)
    {
        printf("参数i输入有误！\n");
        return 0;
    }
    else
    {
        //其实就是尾插法
        s=(Node *)malloc(sizeof(Node));
        s->data=x;
        s->next=p->next;
        p->next=s;
        return 1;
    }
}

//单链表删除操作

int Delete_LinkList(LinkList L,int i)
{
    //在带头结点的单链表L中删除第i个元素
    Node *pre,*r;
    int k;
    pre=L;k=0;
    while(pre->next!=NULL&&k<i-1)
    {
        pre=pre->next;
        k++;
    }
    if(pre->next==NULL)
    {
        printf("删除结点的位置i不合理!\n");
        return 0;
    }


    r=pre->next;
    pre->next=r->next;
    //e=r;
    free(r);
    return 1;

}

//display单链表
void Display_LinkList(LinkList L)
{
    //printf("display调用开始\n");
    Node *p;
    ElemType s;
    p=L;
    while(p->next)
    {
        //p=p->next;
        printf("%c  ",p->next->data);
        //printf("  ");
        p=p->next;
    }
    //printf("display调用结束\n");
}




int main()
{
    LinkList L;
    ElemType e,x;
    int i=1,k,j;
    Init_LinkList(&L);
    printf("尾插法建立单链表如下：\n(输入规则：一个数字一个数字地输入，不用加空格和回车，空格和回车也会被当作是一个字符，结束的时候请输入'$')\n");
    CreateFromTail(&L);
    system("cls");
    while(i)//保证一直进行
    {
        printf("\n现在的链表:  ");
        Display_LinkList(&L);
        printf("\n-------------------------------------\n");
        printf("             Main Menu         \n");
        printf("    1   在单链表中查找第i个结点    \n");
        printf("    2   在单链表中查找值为key的结点   \n");
        printf("    3   求单链表的长度   \n");
        printf("    4   单链表插入(在第i个结点插入e)   \n");
        printf("    5   单链表删除操作   \n");
        printf("    6   清屏   \n");
        printf("    0   结束程序      \n");
        printf("--------------------------------------\n");
        printf("请输入你选择的菜单号<1, 2, 3, 4, 5, 6, 0>:\n");
        scanf("%d",&i);
        switch(i)
        {
        case 1:
            printf("请输入要查找的结点：");
            scanf("%d",&x);
            Node *p1;
            p1=Get(&L,x);
            //printf("%d",p1->data-48);
            printf(p1);
            printf("\n");
            break;
        case 2:
            printf("请输入要查找的值key：");
            //char key;
            scanf("%d",&x);
            //Node *p2;
            Locate(&L,x+48);
            printf("\n\n");
            break;
        case 3:
            printf("长度为");
            //ListLength(&L);
            int p3=ListLength(&L);
            printf("\n\n");
            break;
        case 4:
            printf("要插入到哪个结点前？\n");
            int i;
            scanf("%d",&i);
            int e;
            printf("要插入哪个值呢？\n");
            scanf("%s",&e);
            Insert_LinkList(&L,i,e);
            printf("\n\n");
            break;
        case 5:
            printf("要删除到哪个结点呢？\n");
            int ii;
            scanf("%d",&ii);
            ElemType ee;
            Delete_LinkList(&L,ii);
            printf("\n\n");
            break;
        case 6:
            system("cls");
            break;
        case 0:
                exit(0);
                break;
        default:
            printf("输入有误~");
        }
    }
return 0;
}
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

数据结构

链表

c语言

数据结构--单链表的c语言实现（超详细注释/实验报告） 的相关文章

  • 算法工程师福利：超实用技术路线图

    对于不同级别的算法工程师技能要求 我们大致可以分成以下几个层级 初级 可以在一些指导和协助下独立完成开发任务 具体到算法方面 需要你对于工具框架 建模技术 业务特性等方面有一定的了解 可以独立实现一些算法项目上的需求 中级 可以基本独立完成

  • USB+HOST+FATFS

    转载https blog csdn net zcshoucsdn article details 78944536

  • Mysql 5.6 双主配置 自动同步脚本

    最近有项目应用到了 mysql 双主结构 现在贴出来共享 mysql 版本 5 6 11 操作系统版本 rhel 6 2 Master 的 my cnf 配置 只贴M M 结构部分 log bin fabian server id 1 bi

  • 【Deep Learning】Hinton. Reducing the Dimensionality of Data with Neural Networks Reading Note

    2006年 机器学习泰斗 多伦多大学计算机系教授Geoffery Hinton在Science发表文章 提出基于深度信念网络 Deep Belief Networks DBN 可使用非监督的逐层贪心训练算法 为训练深度神经网络带来了希望 如

  • Houdini中全景摄像机shader立体左右眼成像方法

    熟悉Houdini Shader部分的同学应该多多少少也了解camera自身也可以设定自己的shader 其中polar panoramic shader 能够非常方便的为艺术家渲染360全景视角的cg画面 但是这样渲染出来的画面只是单眼所

  • md5加密

    crypto模块 crypto模块 封装了一系列密码学相关的功能 下载该模块 npm install save crypto 使用 crypto createHash md5 update 加密数据 digest hex 示例

  • 线程的状态与切换

    Java中的线程的生命周期大体可分为5种状态 1 新建 初始化 NEW 新创建了一个线程对象 2 可运行 RUNNABLE 线程对象创建后 其他线程 比如main线程 调用了该对象的start 方法 该状态的线程位于可运行线程池中 等待被线

随机推荐

  • react入门，适合新手小白！

    1 1官方网站 中文官网 React 官方中文文档 用于构建用户界面的 JavaScript 库 2 react简介 1 2 1 React是什么 主要是帮助咱们操作界面 也就是操作视图呈现页面 1 2 2 为什么要学React 易于学习

  • Hive（完整版）

    Hive 1 基本概念 Hive本质上是基于 Hadoop 的一个数据仓库工具 可以将结构化的数据文件映射为一张表 并 提供类 SQL 查询功能 通俗一点就是Hive相当于一个hadoop的客户端 利用hdfs存储数据 利用mapreduc

  • 【CV】第 10 章：使用 R-CNN、SSD 和 R-FCN 进行目标检测

    大家好 我是Sonhhxg 柒 希望你看完之后 能对你有所帮助 不足请指正 共同学习交流 个人主页 Sonhhxg 柒的博客 CSDN博客 欢迎各位 点赞 收藏 留言 系列专栏 机器学习 ML 自然语言处理 NLP 深度学习 DL fore

  • JAVA计算摘要，例如MD5和SHA-256

    摘要有什么用 1 保证数据的完整性 例如你发送一个100M的文件给你的B 但是你不知道B收到的是否是完整的文件 此时你首先使用摘要算法 如MD5 计算了一个固定长度的摘要 将这个摘要和文件一起发送给B B接收完文件之后 同样使用MD5计算摘

  • Android 使用SwipeRefreshLayout实现RecyclerVeiw的下拉刷新和上拉加载

    博主前些天发现了一个巨牛的人工智能学习网站 通俗易懂 风趣幽默 忍不住也分享一下给大家 点击跳转到网站 实现下拉刷新和上拉加载的完整代码如下 一 布局文件代码如下 主界面main xml代码

  • PLSQL性能优化方法

    转载自http www itfarmer com cn 1 选择最有效率的表名顺序 只在基于规则的优化器中有效 ORACLE的解析器按照从右到左的顺序处理FROM子句中的表名 FROM子句中写在最后的表 基础表driving table 将

  • stm32f407+cjson的避坑

    1 添加cjson库文件后 编译工程文件 报错 提示 CJSON test c 461 error 268 declaration may not appear after executable statement in block 如下图

  • python 使用socket建立小型聊天室

    一个聊天室 由两个部分组成 服务端和客户端 服务端接收客户端发来的消息 并将接收到的消息发送给其他客户端 客户端负责发送消息到服务端 并接收来自服务端发送的来自其他客户端的消息 示例图 服务端和客户端 这是属于一个群聊的聊天室 服务端会把每

  • 淦、我的服务器又被攻击了

    作者简介 CSDN top100 阿里云博客专家 华为云享专家 网络安全领域优质创作者 推荐专栏 对网络安全感兴趣的小伙伴可以关注专栏 网络安全入门到精通 最近老是有粉丝问我 被黑客攻击了 一定要拔网线吗 还有没有别的方法 按理说 如果条件

  • Python使用os.path.join只保留最后一个变量的原因

    在使用Python的os path join a path bbb ccc 来合并路径时 合并的结果如果只保留了最后的 ccc 是因为最后的一个变量名包含了斜杠 函数会将其识别成绝对路径 因此就会忽略前面所以的其他路径

  • File类的知识

    File 文章目录 File 概述 构造方法 抽象路径 成员方法 创建 删除 判断和获取和遍历 判断 获取 遍历 概述 java编写的一个专门用于描述计算机中的文件和文件夹的类 1 是文件和目录路径名的抽象表示 2 文件和目录是可以通过Fi

  • System has not been booted with systemd as init system (PID 1). Can‘t operate

    system has not been booted with systemd as init system pid 1 can t operate Error 报错 System has not been booted with syst

  • SMTP协议解读以及如何使用SMTP协议发送电子邮件

    电子邮件协议中POP3协议用于接收邮件 SMTP协议用于发送邮件 SMTP的全称为Simple Mail Transfer Protocol 也就是简单邮件传输协议 字如其名 相较于POP3而言 SMTP确实比较简单 这里的简单并不是指SM

  • 李承鹏小说

    1 李可乐抗拆记 城镇化进程 拆迁是个大事情 房子是普通老百姓生活中最重要的东西 一个被拆迁的社区就是一个矛盾激化的社会 有人想终于可捞一笔了 一辈子也就这么一次暴富的机会 有人喜欢老地方 不在乎钱 就不要搬 大部分都是乐意搬 只要补偿合理

  • SprongBoot集成MinIo

    SprongBoot集成MinIo 1 集成MinIo 1 1 添加依赖

  • 第八篇 VGGNet——网络实战

    文章目录 摘要 1 项目结构 2 划分训练集和测试集 3 计算mean和Standard 3 1 标准化的作用 3 2 归一化的作用 4 训练 4 1 导入项目使用的库 4 2 设置随机因子

  • 利用ANSYS随机振动分析功能实现随机疲劳分析

    ANSYS随机振动分析功能可以获得结构随机振动响应过程的各种统计参数 如 均值 均方根和平均频率等 根据各种随机疲劳寿命预测理论就可以成功地预测结构的随机疲劳寿命 本文介绍了ANSYS随机振动分析功能 以及利用该功能 按照Steinberg

  • Android SDK Android NDK 官方下载地址

    Android SDK Android NDK 官方下载地址 Android NDK r6b Windows http dl google com android ndk android ndk r6b windows zip Mac OS

  • VisualStudio（2022）- 打包项目文件为.exe安装包

    目录 前言 一 安装扩展 二 制作安装包 setup文件 2 1 添加setup项目 2 2 配置setup项目 2 3 添加项目文件到setup项目中 扩展知识 三个文件夹说明 2 4 设置项目主输出 2 5 设置快捷方式 2 6 生成安

  • 数据结构--单链表的c语言实现（超详细注释/实验报告）

    数据结构 单链表的c语言实现 超详细注释 实验报告 知识小回顾 在顺序表中 用一组地址连续的存储单元来一次存放线性表的结点 因此结点的逻辑顺序和物理顺序是一致的 而链表则不然 链表是用一组任意的存储单元来存放线性表的结点 这组储存单元可以是

热门标签