链表实现步骤
C++链表类的实现(面向对象的思想)

//节点的指针复位 pNode = g_World.getObjectLink().m_pHead;
//遍历链表(删除节点) while(pNode != NULL)
{ if(pNode->m_pObject->IsDead()) { //删除节点 g_World.getObjectLink().DeleteNode(pNode->m_pObject); cout<<"删除节点成功"<<endl; count --; break; } pNode = pNode->pNext;
2:删除节点
//
3:插入节点
//程序说明:Class Object,World,LinkObject
//
Object:是节点的数据域的数据
//
World: 用于返回链表对象
//
LinkObject:链表类,提供了对链表操作的基本方法
//代码行数:300
//作者:CreateDBW 时间:2012 年 12 月 10 日
count ++; if(count == flag) {
//为新增的节点分配内存 Node *pInsertNode = new Node(pObj); //新增节点的后一个节点的地址(pNode->pNext) //存储在新增节点(pInsertNode)的 pNext 中. pInsertNode->pNext = pNode->pNext; //把新增节点的地址 pInsertNode 存储到 pNode->pNext //中 pNode->pNext = pInsertNode; return ; } pNode = pNode->pNext; } //如果要插入的节点是在最后就用下面的函数 AddNode(pObj); } LinkObject::~LinkObject() {
实验三四 链表的实现和应用

江南大学物联网工程学院上机报告课程名称 班 级 数据结构 上机名称 姓 名 链表的实现和应 用 上机日期 学 号 2016.3.11 上机报告要求 1.上机名称 2.上机要求 3.上机环境 4.程序清单(写明运行结果) 5.上机体会1.上机名称链表的实现和应用2.上机要求⑴定义线性表的链式存储表示; ⑵基于所设计的存储结构实现线性表的基本操作; ⑶编写一个主程序对所实现的线性表进行测试; ⑷线性表的应用:①设线性表 L1和 L2分别代表集合 A 和 B,试设计算法求 A 和 B 的并集 C,并用线 性表 L3代表集合 C;②设线性表 L1和 L2中的数据元素为整数,且均已按值非递减有序排列,试 设计算法对 L1和 L2进行合并,用线性表 L3保存合并结果,要求 L3中的数据元素也按值非递减 有序排列。
⑸设计一个一元多项式计算器,要求能够:①输入并建立多项式;②输出多项式;③执行两个多项式 相加;④执行两个多项式相减;⑤(选做)执行两个多项式相乘。
3.上机环境Visual C++ 6.04.程序清单(写明运行结果)(1) #include<stdio.h> #include<stdlib.h> typedef int datatype; typedef struct node { datatype data; struct node *next; }LinkList; LinkList *CREATLISTF(LinkList *L,int n) { intnum,i; LinkList *head,*s,*r; head=L; r=head; head->next=NULL;printf("请输入集合中的元素(由小到大) :\n"); for(i=0;i<n;i++) { scanf("%d",&num); s=(LinkList*)malloc(sizeof(LinkList)); s->data=num; r->next=s; r=s; } r->next=NULL; return head; } LinkList *merge(LinkList *L1,LinkList *L2) { LinkList *L3,*pa,*pb1,*pb2,*pc; L3=(LinkList*)malloc(sizeof(LinkList)); L3->next=NULL; pa=L1->next; pb1=pb2=L2->next; pc=L3; while(pa && pb1) if(pa->data<pb1->data) { pc->next=pa;pc=pa; pa=pa->next; } else if(pa->data>pb1->data) { pc->next=pb1;pc=pb1; pb1=pb1->next; } else { pc->next=pa; pc=pa;pa=pa->next;pb1=pb2=pb1->next; } if(pa)pc->next=pa; else pc->next=pb1; return(L3); } void display(LinkList *L) { LinkList *head; head=L->next;do { printf("%d\t",head->data); head=head->next; }while(head!=NULL); } void main() { intan,bn; LinkList *L1,*L2,*L3; L1=(LinkList*)malloc(sizeof(LinkList)); L2=(LinkList*)malloc(sizeof(LinkList)); printf("\n 集合 A 中元素的个数:\n"); scanf("%d",&an); *L1=*CREATLISTF(L1,an); printf("集合 A 的元素为:\n"); display(L1); printf("\n 集合 B 中元素的个数:\n"); scanf("%d",&bn); *L2=*CREATLISTF(L2,bn); printf("集合 B 的元素为:\n"); display(L2); L3=merge(L1,L2); printf("\n 集合 A 与集合 B 的并集为:\n"); display(L3); }(2) #include<stdio.h> #include<stdlib.h> struct node { intexp; float coef; struct node *next; }; typedef struct node ListNode; ListNode *createpoly() { ListNode *h=NULL,*p,*q=NULL; int e; float c; printf("请输入系数和指数:"); scanf("%f,%d",&c,&e); while(e!=0||c!=0) { p=(ListNode*)malloc(sizeof(ListNode)); p->coef=c; p->exp=e; p->next=NULL; if(h==NULL) h=p; else q->next=p; q=p; printf("请输入系数和指数:"); scanf("%f,%d",&c,&e); } return h; } void disppoly(ListNode *h) { ListNode *p; p=h; while(p!=NULL) { if(p->exp==0) printf("%.2f",p->coef); else printf("%fx^%d",p->coef,p->exp); p=p->next;if(p!=NULL) printf("+"); } printf("\n"); } ListNode *addpoly(ListNode *h1,ListNode *h2) { ListNode *p,*r=NULL,*s1,*s2,*s=NULL; float c; int e; s1=h1; s2=h2; while(s1!=NULL&&s2!=NULL) { if(s1->exp==s2->exp) { c=s1->coef+s2->coef; e=s1->exp; s1=s1->next; s2=s2->next; } else if(s1->exp>s2->exp) { c=s1->coef; e=s1->exp; s1=s1->next; } else { c=s2->coef; e=s2->exp; s2=s2->next; } if(c!=0) { p=(ListNode*)malloc(sizeof(ListNode)); p->coef=c; p->exp=e; p->next=NULL; if(s==NULL) s=p; else r->next=p; r=p;} } while(s1!=NULL) { c=s1->coef; e=s1->exp; s1=s1->next; if(c!=0) { p=(ListNode*)malloc(sizeof(ListNode)); p->coef=c; p->exp=e; p->next=NULL; if(s==NULL) s=p; else r->next=p; r=p; } } while(s2!=NULL) { c=s2->coef; e=s2->exp; s2=s2->next; if(c!=0) { p=(ListNode*)malloc(sizeof(ListNode)); p->coef=c; p->exp=e; p->next=NULL; if(s==NULL) s=p; else r->next=p; r=p; } } return s; } void deletepoly(ListNode *h) { ListNode *p,*r=h; while(r!=NULL){ p=r->next; free(r); r=p; } } void main() { ListNode *head1,*head2,*head; printf("第一个多项式为:\n"); head1=createpoly(); printf("第二个多项式为:\n"); head2=createpoly(); printf("将两个多项式相加后得:\n"); head=addpoly(head1,head2); disppoly(head); deletepoly(head); }5.上机体会并集的表示有两种方法,顺序结构和链式结构,首先先要搞清楚这两者的区别,然后再加以编写,改进程 序。
数据结构-单链表基本操作实现(含全部代码)

数据结构-单链表基本操作实现(含全部代码)今天是单链表的实现,主要实现函数如下:InitList(LinkList &L) 参数:单链表L 功能:初始化时间复杂度 O(1)ListLength(LinkList L) 参数:单链表L 功能:获得单链表长度时间复杂度O(n)ListInsert(LinkList &L,int i,ElemType e) 参数:单链表L,位置i,元素e 功能:位置i后插时间复杂度O(n)[加⼊了查找]若已知指针p指向的后插 O(1)ListDelete(LinkList &L,int i) 参数:单链表L,位置i 功能:删除位置i元素时间复杂度O(n)[加⼊了查找]若已知p指针指向的删除最好是O(1),因为可以与后继结点交换数据域,然后删除后继结点。
最坏是O(n),即从头查找p之前的结点,然后删除p所指结点LocateElem(LinkList L,ElemType e) 参数:单链表L,元素e 功能:查找第⼀个等于e的元素,返回指针时间复杂度O(n)代码:/*Project: single linkeed list (数据结构单链表)Date: 2018/09/14Author: Frank YuInitList(LinkList &L) 参数:单链表L 功能:初始化时间复杂度 O(1)ListLength(LinkList L) 参数:单链表L 功能:获得单链表长度时间复杂度O(n)ListInsert(LinkList &L,int i,ElemType e) 参数:单链表L,位置i,元素e 功能:位置i后插时间复杂度O(n)[加⼊了查找]若已知指针p指向的后插 O(1)ListDelete(LinkList &L,int i) 参数:单链表L,位置i 功能:删除位置i元素时间复杂度O(n)[加⼊了查找]若已知p指针指向的删除最好是O(1),因为可以与后继结点交换数据域,然后删除后继结点。
c语言单链表头插法实现链表逆置

c语言单链表头插法实现链表逆置链表是一种常用的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。
在C语言中,我们可以使用单链表来实现各种操作,如插入、删除和查找等。
本文将介绍如何使用头插法实现链表的逆置。
首先,我们需要定义一个链表节点的结构体,包含数据和指向下一个节点的指针。
代码如下:```ctypedef struct Node {int data;struct Node* next;} Node;```接下来,我们需要实现链表的创建和逆置函数。
首先,创建一个空链表,并将头节点指针指向NULL。
代码如下:```cNode* createList() {Node* head = NULL;return head;}```然后,我们可以实现链表的插入函数,使用头插法将新节点插入到链表的头部。
代码如下:```cNode* insertNode(Node* head, int data) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = data;newNode->next = head;head = newNode;return head;}```接下来,我们可以实现链表的逆置函数,通过遍历链表,将每个节点插入到头部,从而实现链表的逆置。
代码如下:```cNode* reverseList(Node* head) {Node* newHead = NULL;Node* temp = NULL;while (head != NULL) {temp = head->next;head->next = newHead;newHead = head;head = temp;}return newHead;}```最后,我们可以编写主函数,测试链表的逆置功能。
代码如下:```cint main() {Node* head = createList();head = insertNode(head, 1);head = insertNode(head, 2);head = insertNode(head, 3);head = insertNode(head, 4);head = insertNode(head, 5);printf("原链表:");Node* temp = head;while (temp != NULL) {printf("%d ", temp->data);temp = temp->next;}printf("\n");head = reverseList(head);printf("逆置后的链表:");temp = head;while (temp != NULL) {printf("%d ", temp->data);temp = temp->next;}printf("\n");return 0;}```运行以上代码,输出结果如下:```原链表:5 4 3 2 1逆置后的链表:1 2 3 4 5```通过以上代码,我们成功地使用C语言的单链表头插法实现了链表的逆置。
单链表基本操作的实现

单链表基本操作的实现单链表是一种常见的数据结构,它由多个节点组合而成,每个节点包含一个数据元素和一个指向下一个节点的指针。
通过指针,我们可以方便地在单链表中进行插入、删除和遍历等操作。
以下是关于单链表基本操作的实现。
1. 单链表的创建单链表的创建需要定义一个空的头结点,它的作用是方便在链表的头部进行添加和删除节点操作。
一个空的头节点可以在链表初始化的过程中进行创建。
```typedef struct Node{int data;struct Node *next;}Node;Node *createList(){Node *head = (Node*)malloc(sizeof(Node)); //创建空的头节点head->next = NULL;return head; //返回头节点的地址}```2. 单链表的插入单链表的插入可以分为在链表头部插入、在链表尾部插入和在链表中间插入三种情况。
a. 在链表头部插入节点:```void insertAtHead(Node *head, int data){Node *node = (Node*)malloc(sizeof(Node));node->data = data;node->next = head->next;head->next = node;}```b. 在链表尾部插入节点:```void insertAtTail(Node *head, int data){Node *node = (Node*)malloc(sizeof(Node));node->data = data;node->next = NULL;Node *p = head;while(p->next != NULL){p = p->next;}p->next = node;}```c. 在链表中间插入节点:```void insertAtMid(Node *head, int data, int pos){ Node *node = (Node*)malloc(sizeof(Node)); node->data = data;node->next = NULL;Node *p = head;int count = 0;while(p->next != NULL && count < pos-1){ p = p->next;count++;}if(count == pos-1){node->next = p->next;p->next = node;}else{printf("插入位置错误!");}}```3. 单链表的删除单链表的删除可以分为在链表头部删除、在链表尾部删除和在链表中间删除三种情况。
链表的反转与合并掌握链表反转和合并操作的实现

链表的反转与合并掌握链表反转和合并操作的实现链表是一种常见的数据结构,它由一系列节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。
链表的反转和合并是链表操作中常见且重要的操作,在很多编程问题中都有应用。
本文将介绍链表的反转和合并操作的实现方法。
一、链表的反转链表的反转是指将链表中节点的顺序反向排列。
例如,对于链表1→2→3→4→5,反转后的链表为5→4→3→2→1。
实现链表的反转有两种常见的方法:迭代法和递归法。
1. 迭代法迭代法的实现思路是,从链表头节点开始,依次遍历每个节点,将该节点的指针指向前一个节点。
具体步骤如下:1)定义三个指针:当前节点指针cur、前一个节点指针prev、下一个节点指针next。
2)遍历链表,将当前节点的指针指向前一个节点,然后更新prev、cur和next指针的位置。
3)重复上述步骤,直到遍历到链表末尾。
以下是迭代法的实现代码示例(使用Python语言):```pythondef reverse_list(head):prev = Nonecur = headwhile cur:next = cur.nextcur.next = prevprev = curcur = nextreturn prev```2. 递归法递归法的实现思路是,从链表的尾节点开始,依次反转每个节点。
具体步骤如下:1)递归地反转除最后一个节点外的链表。
2)将当前节点的指针指向前一个节点。
3)返回反转后的链表的头节点。
以下是递归法的实现代码示例(使用Python语言):```pythondef reverse_list(head):if not head or not head.next:return headnew_head = reverse_list(head.next)head.next.next = headhead.next = Nonereturn new_head```二、链表的合并链表的合并是指将两个有序链表按照一定的规则合并成一个有序链表。
c语言链表的创建方法

c语言链表的创建方法在C语言中,链表是一种常见的数据结构,它由一系列节点组成,每个节点包含一个值和一个指向下一个节点的指针。
链表可以动态地添加或删除节点,因此在许多应用程序中被广泛使用。
链表的创建方法大致可以分为以下几个步骤:1. 定义一个节点结构体链表的节点通常包含一个值和一个指针,指针指向下一个节点。
因此,我们需要定义一个结构体来表示节点:```struct Node {int data;struct Node* next;};```其中,`data`表示节点的值,`next`表示指向下一个节点的指针。
2. 创建第一个节点创建第一个节点时,我们需要先分配一段内存,然后将节点的值和指针都赋值为NULL:```struct Node* head = NULL;head = (struct Node*)malloc(sizeof(struct Node));head->data = 1;head->next = NULL;```这里我们使用了`malloc`函数来分配内存,并将返回的指针强制转换为`struct Node*`类型,然后将节点的值和指针赋值为1和NULL。
3. 添加新节点添加新节点时,我们需要先找到链表的末尾,然后在末尾添加新节点:```struct Node* newNode = NULL;newNode = (struct Node*)malloc(sizeof(struct Node));newNode->data = 2;newNode->next = NULL;struct Node* current = head;while (current->next != NULL) {current = current->next;}current->next = newNode;```这里我们定义了一个新节点`newNode`,然后遍历链表找到末尾节点,将末尾节点的指针指向新节点。
实验二 链表操作实现

实验二链表操作实现实验日期:2017 年 3 月16 日实验目的及要求1. 熟练掌握线性表的基本操作在链式存储上的实现;2. 以线性表的各种操作(建立、插入、删除、遍历等)的实现为重点;3. 掌握线性表的链式存储结构的定义和基本操作的实现;4. 通过本实验加深对C语言的使用(特别是函数的参数调用、指针类型的应用)。
实验内容已知程序文件linklist.cpp已给出学生身高信息链表的类型定义和基本运算函数定义。
(1)链表类型定义typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别,0为男生,1为女生*/} datatype;typedef struct node{datatype data; /*数据域*/struct node *next; /*指针域*/} LinkNode, *LinkList;(2)带头结点的单链表的基本运算函数原型LinkList initList();/*置一个空表(带头结点)*/void createList_1(LinkList head);/*创建单链表*/void createList_2(LinkList head);/* 创建单链表*/void sort_xh(LinkList head);/*单链表排序*/void reverse(LinkList head);/*对单链表进行结点倒置*/void Error(char *s);/*自定义错误处理函数*/void pntList(LinkList head);/*打印单链表*/void save(LinkList head,char strname[]);/*保存单链表到文件*/任务一创建程序文件linklist.cpp,其代码如下所示,理解LinkList类型和基本运算函数后回答下列问题。
#include <stdio.h>#include <stdlib.h>/*单链表结点类型*/typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别,0为男生,1为女生*/} datatype;typedef struct node{datatype data; /*数据域*/struct node *next; /*指针域*/} LinkNode, *LinkList;/*带表头的单链表的基本运算函数*/LinkList initList();/*置一个空表(带头结点)*/void createList_1(LinkList head);/*创建单链表*/void createList_2(LinkList head);/*创建单链表*/void sort_xh(LinkList head);/*单链表排序*/void reverse(LinkList head);/*单链表倒置*/void Error(char *s);/*自定义错误处理函数*/void pntList(LinkList head);/*打印单链表*/void save(LinkList head,char strname[]);/*保存单链表到文件*//*置一个空表*/LinkList initList(){ LinkList p;p=(LinkList)malloc(sizeof(LinkNode));p->next=NULL;return p;}/*创建单链表*/void createList_1(LinkList head){ FILE *fp;int xh;float sg;int sex;LinkList p;if((fp=fopen("records.txt","r"))==NULL){ Error("can not open file !");return ;}while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex);p=(LinkList)malloc(sizeof(LinkNode));p->data.xh=xh;p->data.sg=sg;p->data.sex=sex;p->next=head->next;head->next=p;}fclose(fp);}/*创建单链表*/void createList_2(LinkList head){ FILE *fp;int xh;float sg;int sex;LinkList p,rear;if((fp=fopen("records.txt","r"))==NULL){ Error("can not open file !");return ;}rear=head;while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex);p=(LinkList)malloc(sizeof(LinkNode));p->data.xh=xh;p->data.sg=sg;p->data.sex=sex;p->next=NULL;rear->next=p;rear=p;}fclose(fp);}/*单链表排序*/void sort_xh(LinkList head){LinkList q,p,u;p=head->next;head->next=NULL;/*利用原表头结点建新的空表*/while(p){ q=p; /*q为被插入的结点*/p=p->next;/*用p记录后继结点*//*遍历新链表查找插入位置*/u=head;while(u->next!=NULL)/*查找插入位置*/{ if(u->next->data.xh>q->data.xh)break;u=u->next;}/*插入在u结点的后面*/q->next=u->next;u->next=q;}}/*单链表倒置*/void reverse(LinkList head){ LinkList p, r;p=head->next;head->next=NULL;while(p){ r=p;p=p->next;/*r指向结点头插到链表*/r->next=head->next;head->next=r;}}/*输出单链表*/void pntList(LinkList head){ LinkList p;p=head->next;while(p!=NULL){printf("%2d: %.2f %d\n",p->data.xh,p->data.sg,p->data .sex);p=p->next;}}/*自定义错误处理函数*/void Error(char *s){ printf("\n %s", s);exit(1); /*返回OS,该函数定义在stdlib.h中*/}/*保存单链表到文件*/void save(LinkList head,char strname[]){ FILE *fp;LinkList p;if((fp=fopen(strname,"w"))==NULL){ printf("can not open file !");return ;}p=head->next;while(p!=NULL){ fprintf(fp,"%2d %5.2f %2d\n",p->data.xh,p->data.sg,p->data.sex);p=p->next;}fclose(fp);}请回答下列问题:(1)由单链表结点类型定义可知,该链表结点类型名为 LinkNode ,结点的指针类型为 LinkList ,向系统申请一个学生结点空间并把起始地址存于上述结点指针变量new 中的语句是: p=(LinkList)malloc(sizeof(LinkNode)); 。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
{
p= p->next;++j;
if(!p||j>i)returnERROR;
e = p->data;
returnOK;
}
#pragmaonce
#defineTRUE 1
#defineFALSE 0
#defineOK 1
#defineERROR 0
#defineINFEASIBLE -1
L = (LinkList)malloc(sizeof(LNode));
L->next = NULL;
for(inti = n;i>0;--i){
LinkList p = (LinkList)malloc(sizeof(LNode));
scanf("%d",&p->data);
p->next = L->next;
while(p&&j<i)
{
p= p->next;++j;
if(!p||j>i)returnERROR;
e = p->data;
returnOK;
}
}
链表实现步骤:
1,创建头文件preConst.h
2,创建链表类型的声明文件:link.h
3,创建链表类型的函数的实现文件:link.cpp。先只实现createList_L和PrintList_L两个函数
4,创建链表类型的函数的测试文件:linkTest.cpp。先只测试createList_L和PrintList_L两个函数:
s->data=e;
s->next=p->next;
p->next=s;
returnOK;
}
Status ListDelete(LNode *L,intpos)
{
LNode *p=L;
LNode *q;
intj=0;
while(p->next&&j<pos-1)
{
p=p->next;
j++;
}
if(j>pos-1||!p->next)
returnERROR;
q=p->next;
p->next=q->next;
printf("Delete %d\n",q->data);
free(q);
returnOK;
}
Status GetElem_L(LinkList L,inti,ElemType &e)
{
LNode *p = L->next;intj= 1;
7,
#include"link.h"
#include<stdlib.h>
voidmain(){
LNode *headPointer = NULL;
intvalue = 0;
CreateList_L(headPointer, 10);
PrintList_L(headPointer);
ListInsert_L(headPointer,6,80);
s->data=e;
s->next=p->next;
p->next=s;
returnOK;
}
Status ListDelete(LNode *L,intpos)
{
LNode *p=L;
Lபைடு நூலகம்ode *q;
intj=0;
while(p->next&&j<pos-1)
{
p=p->next;
j++;
}
if(j>pos-1||!p->next)
PrintList_L(headPointer);
ListDelete_L(headPointer,8,value);
PrintList_L(headPointer);
}
#include"link.h"
#include<stdio.h>
#include<stdlib.h>
voidCreatList_L(LinkList &L,intn){
5,如果以上测试通过,再继续。否则如果有错误的话,通过设置断点的办法进行调试。鼠标双击要调试行的最左边,则出现红色的断点。意味着如果单步调试的话,会在这行代码停下来。
选择菜单中的debug-start debuging开始调试,
暂时中断时,会出现当前局部变量的值,通过检查是否符合预期来检查出错误。
6,继续将ListInsert_L与ListDelete_L完成
PrintList_L(headPointer);
ListInsert_L(headPointer,6,80);
PrintList_L(headPointer);
ListDelete_L(headPointer,8,value);
PrintList_L(headPointer);
}
Status ListInsert(LNode *L,intpos,ElemType e)
{
LNode *p;
LNode *s=(LNode *)malloc(sizeof(LNode));
intj=0;
p=L;
printf("Insert %d in %d\n",e,pos);
while(p&&j<pos-1)
{
p=p->next;
++j;
}
if(!p||j>pos-1)returnERROR;
#defineOVERLOW -2
typedefintStatus;
typedefintElemType;
#pragmaonce
#include"preConst.h"
structLNode{
ElemType data;
structLNode* next;
};
typedefLNode *LinkList;
returnERROR;
q=p->next;
p->next=q->next;
printf("Delete %d\n",q->data);
free(q);
returnOK;
}
Status GetElem_L(LinkList L,inti,ElemType &e)
{
LNode *p = L->next;intj= 1;
voidCreateList_L(LinkList &L,intn);
Status DestroyList_L(LinkList &L);
Status GetElem_L(LinkList L,inti,ElemType &e);
Status ListInsert_L(LinkList &L,inti,ElemType e);
{
LNode *p;
LNode *s=(LNode *)malloc(sizeof(LNode));
intj=0;
p=L;
printf("Insert %d in %d\n",e,pos);
while(p&&j<pos-1)
{
p=p->next;
++j;
}
if(!p||j>pos-1)returnERROR;
L->next = p;
}
}
Status PrintList_L(LinkList L){
LinkList p = L->next;
while(p){
printf("%d",p->data);
p = p->next;
}
returnOK;
}
Status ListInsert(LNode *L,intpos,ElemType e)
Status ListDelete_L(LinkList &L,inti,ElemType &e);
Status PrintList_L(LinkList L);
voidmain(){
LNode *headPointer = NULL;
intvalue = 0;
CreateList_L(headPointer, 10);