数据结构头插法和尾插法建立单链表
单链表头插法代码
单链表头插法代码单链表是一种常见的数据结构，它由多个节点组成，每个节点包括两部分：一个数据存储区和一个指向下一个节点的指针。
插入操作是单链表的基本操作之一，在插入一个节点时，可以采用两种方法：头插法和尾插法。
在本篇文章中，我们将重点讲解单链表的头插法。
头插法是指在单链表的头节点之前插入一个新节点。
这种方法需要先创建一个新节点，并将其指针指向原头节点所指向的节点。
然后再将头节点的指针指向新节点。
相当于是在链表的头部插入新节点。
下面是头插法的代码实现：```struct node {int data;struct node *next;};void insert_node(struct node **head, int value) {struct node *new_node = (struct node*)malloc(sizeof(struct node));new_node->data = value;new_node->next = *head;*head = new_node;}```在上面的代码中，我们首先定义了一个节点结构体node，其中包含一个int类型的数据成员data和一个指向下一个节点的指针成员next。
然后，我们定义一个函数insert_node，这个函数的作用是向单链表中插入新的节点。
其中，head是指向链表头节点的指针，value 是要插入的节点的值。
在insert_node函数体中，我们首先通过malloc函数动态分配内存，创建一个新节点new_node。
然后，将新节点的data成员赋值为value，将新节点的next指针指向原head指针所指向的节点，最后将head指针指向新节点new_node。
这样，新节点就插入到链表的头部了。
总结一下，头插法是单链表中比较常用的一种插入节点的方式，通过这种方法，可以很方便地在链表头部插入新节点。
在实现的过程中需要注意，在创建新节点时要手动分配内存，否则会发生内存错误。
头插法和尾插法建立单链表
#include "stdio.h"#include "stdlib.h"typedef struct List{int data;struct List *next; //指针域}List;void HeadCreatList (List *L) //头插法建立链表{List *s;L->next=NULL;for (int i=0;i<10;i++){s=(struct List*)malloc(sizeof(struct List));s->data=i;s->next=L->next; //将L指向的地址赋值给S;L->next=s;}}void TailCreatList(List *L) //尾插法建立链表{List *s,*r;r=L;for (int i=0;i<10;i++){s=(struct List*)malloc(sizeof(struct List));s->data=i;r->next=s;r=s;}r->next=NULL;}void DisPlay(List *L){List *p=L->next;while(p!=NULL){printf ("%d ",p->data);p=p->next;}printf("\n");}int main (){List *L1,*L2;L1=(struct List*)malloc(sizeof(struct List));L2=(struct List*)malloc(sizeof(struct List)); HeadCreatList(L1);DisPlay(L1);TailCreatList(L2);DisPlay(L2);}//头插法创建链表#include <stdio.h>#include <stdlib.h>struct node{int data;struct node * next;};//建立只含头结点的空链表struct node * create_list(){struct node * head = NULL;head = (struct node *)malloc(sizeof(struct node));if (NULL == head){printf("memory out of use/n");return NULL;}head->next = NULL;head->data = 0;return head;}//头插法建立链表int insert_form_head(struct node * head, int num){struct node * head_t = head->next;struct node * new_node = NULL;new_node = (struct node *)malloc(sizeof(struct node));if (NULL == new_node){printf("memory out of use/n");return -1;}//将新结点插入到链表的最后new_node->data = num;new_node->next = head_t;head->next = new_node;return 0;}//打印链表int show_list(struct node * head){struct node * temp;temp = head->next;while(temp){printf("%d/n",temp->data);temp = temp->next;}return 0;}// 按值删除结点，头结点不被删除int delete_node(struct node *head, int data){//head_t 保存要删除结点的上一个结点struct node * head_t = head;struct node * temp = NULL;if (head == NULL){printf("delete node from empty list!/n");return -1;}//查找删除的结点的前一个结点//如果此处查找的是删除的结点，则需要另加一个指针保存删除结点的前一个指针while(NULL != head_t->next){if (data == head_t->next->data)break;head_t = head_t->next;}//如果要删除的结点不存在，直接返回if (NULL==head_t->next){printf("node not found/n");return -1;}//删除操作temp = head_t->next;head_t->next = head_t->next->next;free(temp);return 0;}void main(int argc, char* argv[]){struct node * head;head = create_list();if (NULL == head)printf("create_list error/n");insert_form_head(head,123);insert_form_head(head,456);show_list(head);printf("delete once!/n");delete_node(head,123);show_list(head);printf("delete second!/n");delete_node(head,456);show_list(head);delete_node(head,0);show_list(head);}/*//尾插法创建链表#include<stdio.h>#include<stdlib.h>struct Node{int data;struct Node * next;};//建立只含头结点的空链表struct Node * create_list(){struct Node * head = NULL;head = (struct Node *)malloc(sizeof(struct Node));if (NULL == head){printf("memory out of use/n");return NULL;}head->next = NULL;head->data = 0;return head;//尾插法建立链表int insert_form_tail(struct Node * head, int num){struct Node * temp = head;struct Node * new_node = NULL;new_node = (struct Node *)malloc(sizeof(struct Node));if (NULL == new_node){printf("memory out of use/n");return -1;}//寻找尾结点while (temp->next != NULL){temp = temp->next;}//将新结点插入到链表的最后new_node->data = num;new_node->next = NULL;temp->next = new_node;return 0;}//打印链表int show_list(struct Node * head){struct Node * temp;temp = head->next;while(temp){printf("%d/n",temp->data);temp = temp->next;}return 0;}void main(int argc, char* argv[]){struct Node * head;head = create_list();if (NULL == head)printf("create_list error/n");insert_form_tail(head,123);insert_form_tail(head,456);show_list(head);*/。
头插法建立单链表学习总结
头插法建⽴单链表学习总结单链表是⼀种链式存储的数据结构，每⼀个节点存放数据和指向下⼀个节点的指针。
头插法是指每次将新节点插⼊头部（head节点之后），最终链表顺序与插⼊顺序相反。
这就好⽐你在⾷堂排队，⼤妈所在窗⼝是头部，每次都有⼈插⼊到队伍最前⾯，结果你是最后买到饭的。
图解：以下代码是新建链表并遍历输出元素#include<stdio.h>#include<stdlib.h>typedef struct _node{int data;struct _node *next;}node;node *headinsert(int n);//创建链表并插⼊新节点void output(node *head);//遍历链表并输出节点数据void destroy(node *head);//清除链表int main(){int n;node *head;scanf("%d",&n);head=headinsert(n);output(head);destroy(head);return0;}node *headinsert(int n){node *head,*q;head=(node *)malloc(sizeof(node));//malloc返回void* 需要强制转换类型head->next=NULL;for(int i=0;i<n;i++){ //申请新节点并插⼊链表q=(node *)malloc(sizeof(node));scanf("%d",&q->data);q->next=head->next;head->next=q;}return head;}void output(node *head){node *q; //新建指针q使其从头节点遍历链表 q=head;while(q->next!=NULL){q=q->next;printf("%d ",q->data);}}void destroy(node *head){node *q,*p;for(p=head;p;p=q){q=p->next;free(p);}}。
《数据结构》-头插法建立单链表
LinkList head;
ListNode *s;
head=NULL;
printf("请输入链表各结点的数据(字符型):\n");
while((ch=getchar())!='\n')
{
s=(ListNode *)malloc(sizeof(ListNode ));
if(s==NULL)
{
printf("申请存储空间失败!");return head;
2020
数据结构
Data structure
头插法建立单链表
讲授：XXX
0.5 头插法建立单链表
要 假三设求、线：性链表表中的结插点入的数据类型是字符型，逐个输入这些字符，并以换行符‘\n’作为输入结束的条
件，使用头插法动态地建立单链表（不带头结点）。
算法思路：
从一个空表开始，重复读入数据，生成新结点，将读入数据存放在新结点的数据域中，然后将新结 点插入到当前链表的表头上，直到读入换行符'\n'为止。
图2-6 新结点前插
图2-7 头指针指向新结点
重复进行第②步到第⑥步，便可建立一个含有多个结点的 不带头结点的单链表，如图2-8。
head s
d
c
b
a^
图2-8 头插法建单链表
04
0.5
05
头插法建立单链表
具体算法：
LinkList CreatListF(void)
{//头插法建立单链表
DataType ch;
算法步骤：
①将头指针head置为
②读取字符ch，判断ch与'\n'是否不相
NULL，转向②。如图2-3。 等，若是转向③，否则，返回head。
头插法与尾插法
#include <stdio.h>#include <stdlib.h>typedef char DataType; //假设节点的数据类型为字符typedef struct node{//节点类型定义DataType data; //节点的数据域struct node *next; //节点的指针域}ListNode;typedef ListNode* LinkList;ListNode *p; //指向某一节点的指针LinkList head; //单链表的头指针//头插法LinkList createListF(void);LinkList createListF(void){//返回单链表的头指针char ch;LinkList head; //头指针ListNode *s; //工作指针head = NULL; //链表开始为空ch = getchar(); //读入第一个字符while (ch != '\n') {s =(ListNode*)malloc(sizeof(ListNode)); //生成新节点s->data = ch; //将读入的数据放入新节点的数据域中s->next = head;head = s;ch = getchar(); //读入下一个字符}return head;}//尾插法LinkList createListR(void);LinkList createListR(void){//返回头指针char ch;LinkList head; //头指针ListNode *s,*r; //工作指针head = NULL; //链表开始为空r = NULL; //尾指针初始值为空ch = getchar(); //读入第一个字符while (ch != '\n') {s =(ListNode*)malloc(sizeof(ListNode)); //生成新节点s->data=ch; //将读入的数据放入新节点的数据域中s->next=NULL;if (head==NULL) {head = s; //新节点插入空表,头节点指向插入的第一个节点r = s; //尾节点指向插入的第一个节点}else{r->next = s; //将新节点查到*r 之后r = s; //尾指针指向新表尾}ch = getchar();} //endwhilereturn head;}int main(int argc, const char * argv[]){LinkList l = createListR();while (l != NULL) {printf("%c",l->data);l = l->next;}printf("\n");return0; }。
不带头结点，头部插入法创建链表
不带头结点，头部插⼊法创建链表#include<stdio.h>#include<stdlib.h>#define ListSize 100typedef int DataType;typedef struct{DataType *data;int length;int size;} Sqlist;void initSqlist(Sqlist *L){L->data = (void*)malloc(ListSize * sizeof(int));if(! L->data) exit(0);L->length = 0;L->size = ListSize;}/*在顺序表的i位置插⼊元素*/void insertSqlist(Sqlist *L,int i,DataType e){int j;DataType *base;if(i<1 || i>L->length+1) exit(0);if(L->length >= L->size){base = (void *) realloc(L->data,(L->length+10)*sizeof(int));if(! base) exit(0);L->data = base;L->size = L->length +10;}for(j = L->length-1;j>= i-1;j--){L->data[j+1] = L->data[j];}L->data[i-1] = e;L->length ++;}/*从顺序表中删除元素*/void delSqlist(Sqlist *L,int i){/*位置是否合法*/int j;if(i<1 || i>L->length +1) exit(0);for(j = i;j < L->length;j++)xx{L->data[j-1] = L->data[j];}L->length --;}int main(){Sqlist L;int i;initSqlist(&L);for(i = 0;i < 15;i++){insertSqlist(&L,i+1,i+1);}for(i = 0;i<15;i++)printf("%d ",L.data[i]);putchar(10);''delSqlist(&L,5);for(i = 0;i<15;i++)printf("%d ",L.data[i]);putchar(10);system("pause");return 0;}上⾯代码实现了顺序表的创建。
单链表的 基本操作
单向链表单向链表的基本操作,创建一个由6个节点组成的单向链表，显示链表中每个节点的数据，并且做增加、删除、查找节点以及计算单链表的长度等处理。
➢需求分析：1.功能（1）用尾插法创建一带头结点的由6个节点组成的单向链表：从键盘读入一组整数，作为单链表中的元素，输入完第6个结点后结束;将创建好的单链表元素依次输出到屏幕上。
（2）显示链表中每个节点的数据（3）从键盘输入一个数,查找在以上创建的单链表中是否存在该数；如果存在,显示它的位置，即第几个元素;如果不存在，给出相应提示如“No found node!”。
（4）在上述的单链表中的指定位置插入指定数据，并输出单链表中所有数据。
(5）删除上述单链表中指定位置的结点，并输出单链表中所有数据。
(6）求单链表的长度并输出.2．输入要求先输入单链表中结点个数n,再输入单链表中所有数据，在单链表中需查找的数据，需插入的数据元素的位置、值，要删除的数据元素的位置。
3。
测试数据单链表中所有数据：12，23,56，21，8，10在单链表中需查找的数据：56；24插入的数据元素的位置、值：1，28；7,28；0，28要删除的数据元素的位置:6➢概要设计：1.算法思想：由于在操作过程中要进行插入、删除等操作，为运算方便，选用带头结点的单链表作数据元素的存储结构.对每个数据元素，由一个数据域和一个指针域组成，数据域放输入的数据值，指针域指向下一个结点。
2.数据结构：单链表结点类型:typedef struct Liistnode ｛int data；struct Listnode *next;｝NODE;3.模块划分：a)用尾插法建立带头结点的单链表＊CreateList函数；b)显示链表中每个结点的数据PrintList函数;c)从键盘输入一个数，查找单链表中是否存在该数FoundList函数；d)在单链表中指定位置插入指定数据并输出单链表中所有数据InsertList函数;e)删除单链表中指定位置的结点并输出单链表中所有数据DeleteList函数；f)计算单链表的长度并在屏幕上输出LengthList函数;g)主函数main()，功能是给出测试数据值，建立测试数据值的带头结点的单链表,调用PrintList函数、FoundList函数、InsertList函数、DeleteList函数、LengthList函数实现问题要求。
数据结构(头插法建立单链表)
数据结构（头插法建立单链表）
假设线性表中结点的数据类型是字符型，逐个输入这些字符，并以换行符‘\n’作为输入结束的条件，使用头插法动态地建立单链表（不带头结点）。
算法思路：
从一个空表开始，重复读入数据，生成新结点，将读入数据存放在新结点的数据域中，然后将新结点插入到当前链表的表头上，直到读入换行符'\n'为止。
具体算法：
LinkList CreatListF(void)
{//头插法建立单链表
DataType ch;
LinkList head;
ListNode *s;
head=NULL;
printf("请输入链表各结点的数据(字符型):\n");
while((ch=getchar())!='\n')
{
s=(ListNode *)malloc(sizeof(ListNode ));
if(s==NULL)
{
printf("申请存储空间失败!");return head;
}
s->data=ch; //输入的数据写入结点数据域s->next=head; //将新结点*s插入链表的前面
head=s; //头指针指向新结点
}
return head;。
数据结构需要掌握的算法
调用上述算法的语句为fun(a,n,0)，求其时间复杂度。
解 ： 设 fun(a,n,0) 的 时 间 复 杂 度 为 T(n), 则 fun(a,n,k)的执行时间为T1(n,k)，由fun()算法可知：
T1(n,k)=n 当k=n-1时 T1(n,k)= (n-k)+T1(n,k+1) 其他情况
对于表达式“(56-20)/(4+2)”,其转换成后缀表达 式的过程 如下：
exp (56-20)/(4+2) 56-20)/(4+2) 操作过程 遇到 ch 为“ (”, 将此括号进栈 op。 遇 到 ch 为 数 字 , 将 56 存 入 postexp 中 , 并 插 入 一 个 字 符 “#”。 遇到 ch 为“ -”, 由于 op 中“ (” 以前没有字符 , 则直接将 ch 进 栈op中。 遇到ch为数字,将20#存入数组 exp中。 ( ( 56# op postexp
O(1)<O(log2n)<O(n)<O(n*log2n)<O(n2)<O(n3)<O(2n)<O(n!)
例 1.8 求两个 n 阶方阵的相加 C=A+B 的算法如下 ,分 析其时间复杂度。
#define MAX 20 /*定义最大的方阶*/
void matrixadd(int n, int A[MAX][MAX],
链式存储（头插法、尾插法）
链式存储（头插法、尾插法）#include "stdio.h"#include "string.h"#include "ctype.h"#include "stdlib.h"#include "io.h"#include "math.h"#include "time.h"#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define MAXSIZE 20 // 存储空间初始分配量typedef int Status;// Status是函数的类型,其值是函数结果状态代码。
如OK等typedef int ElemType;//ElemType类型依据实际情况⽽定，这⾥如果为intStatus visit(ElemType c){printf("%d ",c);return OK;}typedef struct Node{ElemType data;struct Node *next;}Node;typedef struct Node *LinkList; // 定义LinkList// 初始化顺序线性表Status InitList(LinkList *L){*L=(LinkList)malloc(sizeof(Node)); // 产⽣头结点,并使L指向此头结点if(!(*L)) // 存储分配失败return ERROR;(*L)->next=NULL; //指针域为空return OK;}//初始条件：顺序线性表L已存在。
操作结果：若L为空表，则返回TRUE，否则返回FALSEStatus ListEmpty(LinkList L){if(L->next)return FALSE;elsereturn TRUE;}// 初始条件：顺序线性表L已存在。
数据结构实验报告-单链表
2016级数据结构实验报告实验名称：实验一线性表——题目1学生姓名：李文超班级：2015661131班内序号：15学号：2015522147日期：2016年11月13日1.实验要求实验目的：根据线性表的抽象数据类型的定义，选择下面任一种链式结构实现线性表，并完成线性表的基本功能。
线性表存储结构（五选一）：1、带头结点的单链表2、不带头结点的单链表3、循环链表4、双链表5、静态链表线性表的基本功能：1、构造：使用头插法、尾插法两种方法2、插入：要求建立的链表按照关键字从小到大有序3、删除4、查找5、获取链表长度6、销毁7、其他：可自行定义编写测试main()函数测试线性表的正确性。
2.程序分析2.1 存储结构单链表的存储：（1）链表用一组任意的存储单元来存放线性表的结点。
这组存储单元既可以是连续的，也可以是不连续的，甚至零散地分布在内存的某些位置。
（2）链表中结点的逻辑次序和物理次序不一定相同。
为了能正确表示结点间的逻辑关系，在存储每个元素值的同时，还要存储该元素的直接后继元素的位置信息，这个信息称为指针或链。
结点结构┌──┬──┐ data 域---存放结点值的数据域│data │next │ next 域---存放结点的直接后继的地址的指针域└──┴──┘单链表在内存中的存储示意地址 内存单元1000H头指针 1020H1080H10C0H2.2 关键算法分析1、关键算法：（1）头插法自然语言描述：a:在堆中建立新结点b:将a[i]写入到新结点的数据域c:修改新结点的指针域d:修改头结点的指针域。
将新结点加入链表中伪代码描述a:Node <T> * s=new Node <T>b:s->data=a[i]c:s->next=front->next;d:front->next=s（2）尾插法自然语言描述：a:在堆中建立新结点：b:将a[i]写入到新结点的数据域：c:将新结点加入到链表中d:修改修改尾指针伪代码描述a:Node <T> * s=new Node <T>b:s->data=a[i]c:r->next=s;d:r=s（3）遍历打印函数自然语言描述：a:判断该链表是否为空链表，如果是，报错b:如果不是空链表，新建立一个temp指针c:将temp指针指向头结点d:打印temp指针的data域e:逐个往后移动temp指针，直到temp指针的指向的指针的next域为空伪代码描述a: If front->next==NULL①Throw ”an empty list ”②Node<T>* temp=front->next;b:while(temp->next)c:cout<<temp->data<<" ";d:temp=temp->next;(4) 获取链表长度函数自然语言描述：a:判断该链表是否为空链表，如果是，输出长度0b:如果不是空链表，新建立一个temp指针，初始化整形数n为0c:将temp指针指向头结点d:判断temp指针指向的结点的next域是否为空，如果不是，n加一，否则return ne: 使temp指针逐个后移，重复d操作，直到temp指针指向的结点的next域为0，返回n伪代码描述a:if ront->next==NULLb:Node<T>* temp=front->next;c:while(temp->next)d:temp=temp->next;（5）析构/删除函数自然语言描述：a:新建立一个指针，指向头结点b:判断要释放的结点是否存在，c:暂时保存要释放的结点d:移动a中建立的指针e:释放要释放的指针伪代码描述a:Node <T> * p=frontb:while(p)c:front=pd:p=p->nexte:delete front（6）按位查找函数自然语言描述：a:初始化工作指针p和计数器j，p指向第一个结点，j=1b:循环以下操作，直到p为空或者j等于1①：p指向下一个结点②：j加1c:若p为空，说明第i个元素不存在，抛出异常d:否则，说明p指向的元素就是所查找的元素，返回元素地址伪代码描述a:Node <T> * p=front->next;j=1;b:while(p&&j!=1)①:p=p->next②:j++c:if(!p) throw ”error”d:return p（7）按位查找函数自然语言描述：a:初始化工作指针p和计数器j，p指向第一个结点，j=1b:循环以下操作，找到这个元素或者p指向最后一个结点①：判断p指向的结点是不是要查找的值，如果是，返回j，否则p指向下一个结点，并且j的值加一c:如果找到最后一个结点还没有找到要查找的元素，返回查找失败信息伪代码描述a:Node <T> * p=front->next;j=1;b:while(p)①: if(p->next==x) return jp=p->nextj++c:return “error”（8）插入函数自然语言描述：a:在堆中建立新结点b:将要插入的结点的数据写入到新结点的数据域c:修改新结点的指针域d:修改前一个指针的指针域，使其指向新插入的结点的位置伪代码描述a:Node <T> * s=new Node <T>;b:s-data=p->datac:s->next=p->nextd:p->next=se:p->data=x（9）删除函数自然语言描述：a:从第一个结点开始，查找要删除的位数i前一个位置i-1的结点b:设q指向第i个元素c:将q元素从链表中删除d:保存q元素的数据e:释放q元素伪代码描述a:q=p->nextb:p->next=q->nextc:x=q->datad:delete q2、代码详细分析（插入）：（1）从第一个结点开始，查找节点，使它的数据比x大，设p指向该结点：while (x>p->data) { p=p->next;}（2）新建一个节点s，把p的数据赋给s：s->data=p->data;（3）把s加到p后面：s->next=p->next; p->next=s;（4）p节点的数据用x替换：p->data=x;示意图如图所示xp->datas3、关键算法的时间复杂度：O（1)3.程序运行结果1. 流程图：2、结果截图3.测试结论：可以正确的对链表进行插入，删除，取长度，输出操作。
国家开放大学《数据结构》课程实验报告(实验2——线性表)参考答案
//在链表中删除最高分和最低分结点
for(q=head,p=head->next;p!=NULL;q=p,p=p->next)
{
if(p==pmin) { q->next=p->next; p=q; } //删除最低分结点
};
typedef struct pw PW;
//定义链表结点
struct node
{
PW data;
struct node * next;
};
typedef struct node NODE;
NODE *create(int n); //建立单链表
void input(NODE *s,int i); //输入第i个评委信息
（5）遍历链表，累加求和，计算总分及平均分，并输出相关信息。
完整程序
//实验1.1线性表的链接存储结构
#include
#include
#include
#define PWRS 5 //定义评委人数
//定义评委信息
struct pw
{
char name[8]; //姓名
short age; //年龄
float score; //评分
NODE *create(int n)
{
NODE *head,*p,*q;
inti;
p=(NODE*)malloc(sizeof(NODE));
head=p; q=p; p->next=NULL;
for(i=1; i<=n; i++)
{
p=(NODE*)malloc(sizeof(NODE));
数据结构之单链表头插法，尾插法
数据结构之单链表头插法，尾插法数据结构之单链表头插法，尾插法单链表是中的⼀种，单链表的头插法也称前插法。
链表也是线性表的⼀种，与顺序表不同的是，它在内存中不是连续存放的。
在C语⾔中，链表是通过指针相关实现的。
⽽单链表是链表的其中⼀种，关于单链表就是其节点中有数据域和只有⼀个指向下个节点的指针域。
创建单链表的⽅法有两种，分别是头插法和尾插法。
所谓头插法，就是按节点的逆序⽅法逐渐将结点插⼊到链表的头部。
反之尾插法就是按节点的顺序逐渐将节点插⼊到链表的尾部。
相对来说，头插法要⽐尾插法算法简单，但是最后产⽣的链表是逆序的，即第⼀个输⼊的节点实际是链表的最后⼀个节点。
⽽为了习惯，通常⽤尾插法来创建链表。
下⾯的代码就是实现了头插法和尾插法创建头节点//创建头结点Node* Create_List (){//创建头结点Node* list = (Node*) malloc(sizeof(Node) / sizeof(char));if (NULL == list) //检验创建是否成功{return FALSE;}list->next = NULL;return list;}头插法// 头插法int Insert_Last (Node* h, LinkData data){// 判断数据传⼊是否正确if (NULL == h){return FALSE;}// 创建新结点并判断创建是否成功Node* node = (Node*) malloc(sizeof(Node) / sizeof(char));if (NULL == node){return FALSE;}// 给结点成员变量赋值node->data = data;node->next = h->next; // 和头指针的不同：node->next = *h;// 让新结点变为链表的第⼀个节点h->next = node;return TRUE;}尾插法//尾插int Insert_Last(Node* h, LinkData data){if (NULL == h){return FALSE;}// 创建新结点并判断创建是否成功Node* node = (Node*) malloc(sizeof(Node) / sizeof(char));if (NULL == node){return FALSE;}// 给结点成员变量赋值node->data = data;node->next = NULL;// 让新结点变为链表的最后⼀个节点Node* tmp = h;while(tmp->next){tmp = tmp->next;}//找到链表的尾节点并令尾节点指向nodetmp->next = node;return TRUE;}扩充中间插⼊//中间插⼊法int Insert_Pos(Node *h, int pos, LinkData data){//判断链表是否存在if (NULL == h){return FALSE;}Node* tmp = h;int i;for (i = 0; i < pos - 1; i++){if (NULL == tmp){break;}tmp = tmp->next;}//判断tmp是否存在if (NULL == tmp){printf ("插⼊位置越界");return FALSE;}Node* node = (Node*) malloc(sizeof(Node) / sizeof(char)); if (NULL == node){return FALSE;}node->data = data;node->next = tmp->next;tmp->next = node;return TRUE;}。
数据结构头插法和尾插法建立链表（各分有无头结点）
实验一链表的建立及基本操作方法实现一、【实验目的】1、理解和掌握单链表的类型定义方法和结点生成方法。
2、掌握利用头插法和尾插法建立单链表和显示单链表元素的算法。
3、掌握单链表的查找（按序号）算法。
4、掌握单链表的插入、删除算法。
二、【实验内容】1、利用头插法和尾插法建立一个无头结点单链表，并从屏幕显示单链表元素列表。
2、利用头插法和尾插法建立一个有头结点单链表，并从屏幕显示单链表元素列表。
3、将测试数据结果用截图的方式粘贴在程序代码后面。
重点和难点：尾插法和头插法建立单链表的区别。
建立带头结点和无头结点单链表的区别。
带头结点和无头结点单链表元素显示方法的区别三、【算法思想】1) 利用头插法和尾插法建立一个无头结点单链表链表无头结点，则在创建链表时，初始化链表指针L=NULL。
当用头插法插入元素时，首先要判断头指针是否为空，若为空，则直接将新结点赋给L,新结点nex t指向空，即L=p,p->next=NULL，若表中已经有元素了，则将新结点的n ext指向首结点，然后将新结点赋给L即（p->next=L,L=p）。
当用尾插法插入元素时，首先设置一个尾指针ta i lPoi nter以便随时指向最后一个结点，初始化tai lPoin ter和头指针一样即tailP ointe r=L。
插入元素时，首先判断链表是否为空，若为空，则直接将新结点赋给L即L=p，若不为空，else将最后一个元素的next指向新结点即tai l Point er->next=p，然后跳出这个i f,else语句，将新结点ne xt指向空，并且将tai lPoin ter指向新结点即p->next=NULL,tailPoi nter=p。
本题目要求利用尾插法建立单链表。
本题目要求利用尾插法建立单链表。
标题：深入探讨：利用尾插法建立单链表的方法与应用一、引言在数据结构与算法领域，单链表是一种基本数据结构，它由若干个节点组成，每个节点包含存储数据的部分和指向下一个节点的指针。
而本文将深入探讨利用尾插法建立单链表的方法与应用，帮助读者更全面地理解这一重要概念。
二、尾插法建立单链表1. 概念介绍尾插法是一种用于建立单链表的方法，其基本思想是从链表的尾部开始插入新的节点。
具体而言，我们首先找到链表的尾节点，然后将新节点插入到尾节点之后，最后更新尾节点的指针。
通过这种方式，可以逐渐建立起一个完整的单链表。
2. 算法步骤（1）初始化：设定头节点，并将尾指针指向头节点。
（2）循环插入：逐个读取数据，创建新节点，并将新节点插入到尾节点之后，更新尾指针。
（3）结束条件：当读取完所有数据时，建立完成。
3. 代码示例以下是用C语言实现尾插法建立单链表的简单示例代码：```c#include <stdio.h>#include <stdlib.h>typedef struct Node {int data;struct Node *next;} Node;Node* createList(int arr[], int n) {Node *head = (Node *)malloc(sizeof(Node));head->next = NULL;Node *tail = head;for (int i = 0; i < n; i++) {Node *newNode = (Node *)malloc(sizeof(Node)); newNode->data = arr[i];newNode->next = NULL;tail->next = newNode;tail = newNode;}return head;}void printList(Node* head) {Node *p = head->next;while (p != NULL) {printf("%d ", p->data);p = p->next;}}int main() {int arr[] = {1, 2, 3, 4, 5};int n = sizeof(arr) / sizeof(arr[0]); Node *head = createList(arr, n); printList(head);return 0;}```三、尾插法建立单链表的应用1. 数据输入尾插法建立单链表常用于动态读取一系列数据并创建相应的链表。