㈠ 数据结构，线性表中删除某个元素为什么还要把这个元素赋值给e有何意义不去赋值可以么
这需要看线性表是怎么实现的，比如是用链表实现的，那么在删除第i个节点的时候需要释放他的空间，这个时候记录这个节点是必要的，如果是数组的话，记录上次删除的元素的值有时候可能是必要的，提供了一个撤销到上一状态的机会。
㈡ 单链表删除节点操作 为什么被删的节点中的数据要放在e里面
这句话跟删除节点没有关系，而是为了获取被删除节点中的data值，e作为入参，将data的值返回到函数之外。
㈢ 编程实现单链表的建立、插入、删除和查找算法，语言采用C
#include<stdio.h>
#include<stdlib.h>
typedef struct LNode
{
char data;
struct LNode *next;
}LNode,*LinkList;
void InitList(LinkList *L) //初始化
{
*L = (LinkList)malloc(sizeof(LNode));
(*L)->next = NULL;
}
char GetElem(LinkList L,int i) //返回i 位置的元素
{
//L为带头结点的单链表的头指针。
LinkList p;
int j;
p = L->next; j = 1; //初始化，p指向第一个结点，j为计数器
while(p && j<i)
{
p = p->next;
++j;
}
if(!p || j>i) exit(1); //i位置元素不存在
return(p->data);
}
void ListInsert(LinkList *L,int i,char e)//插入
{
//在带头结点的单链线性表L中第i个位置前插入元素e
LinkList p,s;
int j;
p = *L; j = 0;
while(p && j<i-1)//寻找第i-1个结点
{
p = p->next;
++j;
}
if(!p || j>i-1) exit(1); //i位置不正确
s = (LinkList)malloc(sizeof(LNode)); //新结点
s->data = e;
s->next = p->next;
p->next = s;
}
void ListDelete(LinkList *L,int i)//删除i位置元素
{
LinkList p,q;
int j;
p = *L; j = 0;
while(p->next && j<i-1)//寻找第i个结点
{//这以p->next开始是为了避开头结点,头结点不可删除
//而且这样是必须的,这样是为了有被删除点前面结点的地址,这样才能有前继结点,连接删除点的后继结点.
p = p->next;
++j;
}
if(!(p->next) || j>i-1) exit(1); //删除位置不合理
q = p->next; //删除该点
p->next = q->next;
free(q);
}
void CreateList(LinkList *L,int n)
{
//逆位序输入n个元素的值，建立带表头结点的单链线性表L
int i;
LinkList p;
(*L) = (LinkList)malloc(sizeof(LNode));
(*L)->next = NULL; //先建立带头结点的单链表
for(i=n;i>0;--i)
{
p = (LinkList)malloc(sizeof(LNode)); //生成新结点
scanf("%c",&p->data);
fflush(stdin);
p->next = (*L)->next;
(*L)->next = p;
}
//*****************另一插入法**************************
q = *L = (LinkList)malloc(sizeof(LNode));
(*L)->next = NULL;
for(i=n;i>0;--i)
{
p = (LinkList)malloc(sizeof(LNode));
scanf("%c",&p->data);
fflush(stdin);
p->next = NULL;
q->next = p;
q = p;
//q->next = p;
}
//***********************************************************
}
void MergeList(LinkList *La,LinkList *Lb,LinkList *Lc)
{
//链表La,Lb按递增排列
LinkList pa,pb,pc;
pa = (*La)->next;
pb = (*Lb)->next;
(*Lc) = pc = (*La);
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; //插入剩余段
//free(Lb); //释放Lb头结点
}
void display(LinkList *L)
{
LinkList di;
di = (*L)->next;
while(di!=NULL)
{
printf("%c\t",di->data);
di = di->next;
}
printf("\n");
}
void main()
{
LinkList link,link2,link3;
InitList(&link);
InitList(&link2);
CreateList(&link,5);
CreateList(&link2,5);
display(&link);
display(&link2);
MergeList(&link,&link2,&link3);
display(&link3);
}
里面不包括查找,查找的可以用二分查找等等,不想太麻烦就直接用顺序查找吧.
㈣ CAD中曲线、多段线节点太多怎么删除
选中需要删除的曲线跟节点e+空格就可以删除了。
CAD中常用的快捷键如下：
A 圆弧
L 直线
C 圆
I 插入块
B 创建块
H 图案填充
D 标注样式管理器
E 删除
F 圆角
G 群组
M 移动
O 偏移
P 平移
S 拉伸
W 外部块
V 视图对话框
X 分解
Z 显示缩放
T 多行文字
co 复制
MI 镜像
AR 阵列
RO 旋转
SC 比例
LE 引线管理器
EX 延伸
TR 修剪
ST 文字样式管理器
DT 单行文字
PO 单点
XL 参照线
ML 多线
PL 多段线
POL 多边形
REC 矩形
SPL 样条曲线
EL 椭圆
CH 特性
CHA 倒角
BR 打断
DI 查询距离
AREA 面积
ID 点坐标
MA 特性匹配
MASSPROP 质量特性
LS 列表显示
TIME 时间
SETTVAR 设置变量
LA 图层
COLOR 颜色
LT 线型管理
LW 线宽管理
UN 单位管理
TH 厚度
捕捉
㈤ 数据结构（c语言版）中的删除链表中的一个节点
代码如下：
#include <stdio.h>
#include <stdlib.h>
typedef struct List
{
int a;
List* next;
}list;
void newList(list* l)//创建结点
{
list* a[4];
for (int i = 0; i < 4; i++)
{
a[i] = (list*)malloc(sizeof(list));
a[i]->a = i+1 ;
}
l->next = a[0];
a[0]->next = a[1];
a[1]->next = a[2];
a[2]->next = a[3];
a[3]->next = NULL;
}
void printfList(list* l)//打印结点的数据内容
{
printf("该链表的内容是： ");
while (l->next)
{
printf("%d ", l->next->a);
l = l->next;
}
printf(" ");
}
void setList(list* l,int x,int y)
{
list* head = l;
l = l->next;
while (l)
{
if (l->a >=y || l->a <=x)//将结点的数据区与指定区域进行比较
{
head->next = l;//将满足条件的结点连接在新表的最后一个结点
//指针后移
l = l->next;
head = head->next;
}
else
{
//不满足的结点进行删除
list* l1 = l;
l = l->next;
free(l1);
}
}
head->next = NULL;
}
int main()
{
list* l = (list*)malloc(sizeof(List));
newList(l);//初始化链表
printfList(l);//输出旧表内容
setList(l,1,3);//进行修改
printfList(l);//输出修改后的链表
//system("pause");
return 0;
}
(5)单链删除节点为什么要放在e里扩展阅读
链表的特点
1、插入、删除数据效率高，时间复杂度为O(1)级别（只需更改指针指向即可），随机访问效率低，时间复杂度O(n)级别（需要从链头至链尾进行遍历）。
2、和数组相比，内存空间消耗更大，因为每个存储数据的节点都需要额外的空间存储后继指针。
常用的链表类型
1、单链表
1）每个节点只包含一个指针，即后继指针。
2）单链表有两个特殊的节点，即首节点和尾节点。用首节点地址表示整条链表，尾节点的后继指针指向空地址null。
3）性能特点：插入和删除节点的时间复杂度为O（1），查找的时间复杂度为O(n)。
2、循环链表
1）除了尾节点的后继指针指向首节点的地址外均与单链表一致。
2）适用于存储有循环特点的数据，比如约瑟夫问题。
3、双向链表
1）节点除了存储数据外，还有两个指针分别指向前一个节点地址（前驱指针prev）和下一个节点地址（后继指针next）。
2）首节点的前驱指针prev和尾节点的后继指针均指向空地址。
㈥ c语言 链表操作:建立,显示及节点的插入,删除
先写个头文件，包含链表的各种操作。具体代码如下：
#ifndef LINKEDLIST_H_INCLUDED
#define LINKEDLIST_H_INCLUDED
//线性表的单链表存储结构
struct LNode
{
ElemType data;
LNode *next;
};
typedef LNode *LinkList; // 另一种定义LinkList的方法
//单链表线性表的基本操作(12个)
int InitList(LinkList &L)
{
// 操作结果：构造一个空的线性表L
L=(LinkList)malloc(sizeof(LNode)); // 产生头结点,并使L指向此头结点
if(!L) // 存储分配失败
exit(0);
L->next=NULL; // 指针域为空
return 1;
}
void CreateList_L(LinkList &L, int n) // 算法2.11
{
// 逆位序输入（随机产生）n个元素的值，建立带表头结点的单链线性表L
LinkList p;
int i;
L = (LinkList)malloc(sizeof(LNode));
L->next = NULL; // 先建立一个带头结点的单链表
for (i=n; i>0; --i)
{
p = (LinkList)malloc(sizeof(LNode)); // 生成新结点
p->data = rand()%200; // 改为一个随机生成的数字(200以内)
p->next = L->next;
L->next = p; // 插入到表头
}
} // CreateList_L
int DestroyList(LinkList &L)
{
// 初始条件：线性表L已存在。操作结果：销毁线性表L
LinkList q;
while(L)
{
q=L->next;
free(L);
L=q;
}
return 1;
}
int ClearList(LinkList L) // 不改变L
{
// 初始条件：线性表L已存在。操作结果：将L重置为空表
LinkList p,q;
p=L->next; // p指向第一个结点
while(p) // 没到表尾
{
q=p->next;
free(p);
p=q;
}
L->next=NULL; // 头结点指针域为空
return 1;
}
int ListEmpty(LinkList L)
{
// 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE
if(L->next) // 非空
return 0;
else
return 1;
}
int ListLength(LinkList L)
{
// 初始条件：线性表L已存在。操作结果：返回L中数据元素个数
int i=0;
LinkList p=L->next; // p指向第一个结点
while(p) // 没到表尾
{
i++;
p=p->next;
}
return i;
}
int GetElem(LinkList L,int i,ElemType &e) // 算法2.8
{
// L为带头结点的单链表的头指针。当第i个元素存在时,其值赋给e并返回1,否则返回-1
int j=1; // j为计数器
LinkList p=L->next; // p指向第一个结点
while(p&&j<i) // 顺指针向后查找,直到p指向第i个元素或p为空
{
p=p->next;
j++;
}
if(!p||j>i) // 第i个元素不存在
return -1;
e=p->data; // 取第i个元素
return 1;
}
int LocateElem(LinkList L,ElemType e,int(*compare)(ElemType,ElemType))
{
// 初始条件: 线性表L已存在,compare()是数据元素判定函数(满足为1,否则为0)
// 操作结果: 返回L中第1个与e满足关系compare()的数据元素的位序。
// 若这样的数据元素不存在,则返回值为0
int i=0;
LinkList p=L->next;
while(p)
{
i++;
if(compare(p->data,e)) // 找到这样的数据元素
return i;
p=p->next;
}
return 0;
}
int PriorElem(LinkList L,ElemType cur_e,ElemType &pre_e)
{
// 初始条件: 线性表L已存在
// 操作结果: 若cur_e是L的数据元素,且不是第一个,则用pre_e返回它的前驱,
// 返回1;否则操作失败,pre_e无定义,返回-1
LinkList q,p=L->next; // p指向第一个结点
while(p->next) // p所指结点有后继
{
q=p->next; // q为p的后继
if(q->data==cur_e)
{
pre_e=p->data;
return 1;
}
p=q; // p向后移
}
return -1;
}
int NextElem(LinkList L,ElemType cur_e,ElemType &next_e)
{
// 初始条件：线性表L已存在
// 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，
// 返回1;否则操作失败，next_e无定义，返回-1
LinkList p=L->next; // p指向第一个结点
while(p->next) // p所指结点有后继
{
if(p->data==cur_e)
{
next_e=p->next->data;
return 1;
}
p=p->next;
}
return -1;
}
int ListInsert(LinkList L,int i,ElemType e) // 算法2.9。不改变L
{
// 在带头结点的单链线性表L中第i个位置之前插入元素e
int j=0;
LinkList p=L,s;
while(p&&j<i-1) // 寻找第i-1个结点
{
p=p->next;
j++;
}
if(!p||j>i-1) // i小于1或者大于表长
return -1;
s=(LinkList)malloc(sizeof(LNode)); // 生成新结点
s->data=e; // 插入L中
s->next=p->next;
p->next=s;
return 1;
}
int ListDelete(LinkList L,int i,ElemType &e) // 算法2.10。不改变L
{
// 在带头结点的单链线性表L中，删除第i个元素,并由e返回其值
int j=0;
LinkList p=L,q;
while(p->next&&j<i-1) // 寻找第i个结点,并令p指向其前趋
{
p=p->next;
j++;
}
if(!p->next||j>i-1) // 删除位置不合理
return -1;
q=p->next; // 删除并释放结点
p->next=q->next;
e=q->data;
free(q);
return 1;
}
int ListTraverse(LinkList L,void(*vi)(ElemType))
// vi的形参类型为ElemType，与bo2-1.cpp中相应函数的形参类型ElemType&不同
{
// 初始条件：线性表L已存在
// 操作结果:依次对L的每个数据元素调用函数vi()。一旦vi()失败,则操作失败
LinkList p=L->next;
while(p)
{
vi(p->data);
p=p->next;
}
printf("\n");
return 1;
}
LinkList ReverseList(LinkList phead)//实现链表的逆置
{
LinkList p,q,r;
p=phead;
q=r=NULL;
while(p)
{
q=p->next;
p->next=r;
r=p;
p=q;
}
return r;
}
#endif // LINKEDLIST_H_INCLUDED
再写主函数：
#include <stdio.h>
#include <stdlib.h>
typedef int ElemType;
#include "LinkedList.h"
int compare(ElemType c1,ElemType c2)
{
if(c1==c2)
return 1;
else
return 0;
}
void visit(ElemType c)
{
printf("%d ",c);
}
void MergeList_L(LinkList &La, LinkList &Lb, LinkList &Lc)
{
// 已知单链线性表La和Lb的元素按值非递减排列。
// 归并La和Lb得到新的单链线性表Lc，Lc的元素也按值非递减排列。
LinkList pa, pb, pc;
pa = La->next;
pb = Lb->next;
Lc = pc = La; // 用La的头结点作为Lc的头结点
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; // 插入剩余段
free(Lb); // 释放Lb的头结点
} // MergeList_L
int main()
{
LinkList L;
ElemType e,e0;
int i;
InitList(L);
for(i=1; i<=10; i++)
ListInsert(L,1,10-i);
//CreateList_L(L,10);
printf("在L的表尾依次插入10个数据后：L=");
ListTraverse(L,visit);
GetElem(L,4,e);
printf("第4个元素的值为：%d\n",e);
ListDelete(L,4,e); // 删除第4个数据
printf("删除第4个数据后：L=");
ListTraverse(L,visit);
DestroyList(L);
LinkList La, Lb, Lc;
int a[4] = {3,5,8,11};
int b[7] = {2,6,8,9,11,15,20};
InitList(La);
InitList(Lb);
for(i=1; i<=4; i++)
ListInsert(La, i, a[i-1]);
for(i=1; i<=7; i++)
ListInsert(Lb, i, b[i-1]);
printf("La=");
ListTraverse(La,visit);
printf("Lb=");
ListTraverse(Lb,visit);
MergeList_L(La, Lb, Lc);
printf("Lc=");
ListTraverse(Lc,visit);
DestroyList(Lc);
}
你不需要的操作可以注释掉！
㈦ c语言链表问题求解~当对表里最后一个结点删除的时候会出错
问题出现在这个循环里
while(p->next!=NULL)
{
while(p->next->data==e)
{
q=p->next;
p->next=q->next;
free(q);
count++;
}
p=p->next;
}
你的链表是有头结点的链表，假设表中只有头结点和一个节点X，这个节点等于e，现在来一步步分析：
首先，没进入循环之前，p->next就是那个节点X，不等于NULL，到循环内层
由于X节点等于e，所以 while(p->next->data==e) 成立，进入内层循环
在内层循环中把p->next删除，然后p->next就会等于NULL
然后跳出内层循环，执行 p=p->next;，之后p=NULL
这时再回去判断p->next!=NULL，就会引起内存错误~！
㈧ 单链线性表头结点算第一个结点吗如果算 要在单链线性表中第i位置插入一个元素e是不是从头结点算1位
#include <malloc.h>
#define FALSE 0
#define TRUE 1
#define OK 1
#define ERROR 0
#define MaxSize 10
using namespace std;
typedef char ElemType;
typedef struct Node
{
ElemType data;
Node *next;
}Node, *LinkList;
int InitList_L(LinkList *L)
{
*L=(LinkList)malloc(sizeof(Node));
if(!L)
exit (FALSE);
(*L)->next=NULL;
return TRUE;
}
void qcreate(LinkList L)
{
Node *s;
char c;
int flag=1;
while(flag) /* flag初值为1，当输入"#"时，置flag为0，建表结束*/
{
c=getchar();
if(c!='#')
{
s=(Node*)malloc(sizeof(Node)); /*建立新结点s*/
s->data=c;
s->next=L->next;/*将s结点插入表头*/
L->next=s;
}
else
flag=0;
}
}
//计算链表长度
void length(LinkList L)
{
Node *p;
p=L->next;
int j=0;
while(p!=NULL)
{
p=p->next;
j++;
}
printf("%d",j);
printf("\n");
}
//输出链表
void printf(LinkList L)
{
LinkList p;
p=L;
while(p->next!=NULL)
{
p=p->next;
printf("%c",p->data);
}
printf("\n");
}
//对链表排序
void paixu(LinkList L)
{
Node *r,*q,*small;
char temp;
for(r=L->next;r->next!=NULL;r=r->next)
{
small=r;
for(q=r->next;q;q=q->next) /*找到链表中最小字符*/
if(q->data<small->data)
small=q;
if(small!=r)
{
temp=r->data;
r->data=small->data; /*把最小的数值换到P指针所指的位置数值上（原P指针的next指向不变）*/
small->data=temp; /*把原先p指针所指位置的数值填入被置换出的最小字符位置*/
}
}
printf(L);
}
// 查找第i个结点
void Get(LinkList L, int i)
/*在带头结点的单链表L中查找第i个结点，若找到(1≤i≤n)，则返回该结点的存储位置; 否则返回NULL*/
{
int j;
Node *p;
p=L;
j=0; /*从头结点开始扫描*/
while ((p->next!=NULL)&&(j<i))
{
p=p->next; /* 扫描下一结点*/
j++; /* 已扫描结点计数器 */
}
if(i == j)
printf("%c",p->data); /* 找到了第i个结点 */
else
printf("NULL"); /* 找不到，i≤0或i>n */
printf("\n");
}
//在单链表中找到与x相同的数值
void Getchar(LinkList &L)
{
char n;
cout<<"输入这个元素:";
cin>>n;
LinkList p;
p=L;
while(p->data!=n)
{
if(p->next==NULL)
printf("FALSE");
p=p->next;
}
printf("TRUE");
}
// 插入结点
void cins(LinkList L,int i,ElemType x)
/*在带头结点的单链表L中第i个位置插入值为e的新结点s*/
{
Node *pre,*s;
int k;
pre=L;
k=0; /*从"头"开始，查找第i-1个结点*/
while(pre!=NULL&&k<i-1) /*表未查完且未查到第i-1个时重复，找到pre指向第i-1个*/
{
pre=pre->next;
k=k+1;
} /*查找第i-1结点*/
if(!pre) /*如当前位置pre为空表已找完还未数到第i个，说明插入位置不合理*/
{
printf("插入位置不合理!");
}
s=(Node*)malloc(sizeof(Node)); /*申请一个新的结点S */
s->data=x; /*值e置入s的数据域*/
s->next=pre->next; /*修改指针，完成插入操作*/
pre->next=s;
printf("插入成功!链表为：");
}
//删除结点
void del(LinkList L,int i)
/*在带头结点的单链表L中删除第i个元素，并将删除的元素保存到变量e中*/
{
Node *pre,*r;
int k;
pre=L;
k=0;
while(pre->next!=NULL && k<i-1) /*寻找被删除结点i的前驱结点i-1使p指向它*/
{
pre=pre->next;
k=k+1;
} /*查找第i-1个结点*/
if(!(pre->next)) /* 即while循环是因为p->next=NULL或i<1而跳出的,而是因为没有找到合法的前驱位置，说明删除位置i不合法。*/
{
printf("删除结点的位置i不合理!");
}
r=pre->next;
pre->next=pre->next->next; /*修改指针，删除结点r*/
free(r); /*释放被删除的结点所占的内存空间*/
printf("成功删除结点!链表为:");
}
void main()
{
LinkList L;
InitList_L(&L);
int e,i;
char x;
int flag=1;
printf("初始化单链表: (请输入10个以内的字符,以'#'结尾,之间无须空格)\n");
qcreate(L);
printf(L);
while(flag)
{
printf("请选择操作:");
printf("\n");
printf("1.插入结点");
printf("\n");
printf("2.删除结点");
printf("\n");
printf("3.查找第i个元素");
printf("\n");
printf("4.求链表长度 ");
printf("\n");
printf("5.是否能在单链表中找到与x相同的数值");
printf("\n");
printf("6.输出链表");
printf("\n");
printf("7.排序");
printf("\n");
printf("8.退出");
cin>>e;
switch(e){
case 1:printf("请输入要插入的元素值:");
cin>>x;
printf("请输入要在第几个结点处");
cin>>i;
cins(L,i,x);
printf(L);
break;
case 2: printf("请输入你要删除第几个结点: ");
cin>>i;
del(L,i);
printf(L);
break;
case 3:printf("请输入位置i: ");
cin>>i;
printf("数值为:");
Get(L,i);
break;
case 4:printf("链表长度为:");
length(L);
break;
case 5:Getchar(L);
break;
case 6:printf(L);
break;
case 7:paixu(L);
case 8:flag=0;
break;
}
}
}
请参考
㈨ C语言数据结构的链表删除与查找问题~~，实在是被弄晕了啊
#include<stdio.h>
#include<stdlib.h>
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int ElemType;
typedef struct LNode
{
ElemType data; //数据域
struct LNode *next; //指针域
}LNode,*LinkList;
int InitList(LinkList &L) //构造一个空的链表
{
L=(LinkList)malloc(sizeof(LNode)); //分配头结点空间
L->next=NULL; //头结点的指针域置空
return OK;
}
int printf_L(LinkList &L) //输出单链表L中的元素
{
LinkList p;
p=L;
while(p->next)
{
p=p->next;
printf("%d,",p->data);
}
printf("\n");
return OK;
}
//头插法建表
void CreateList(LinkList &L,int n) //逆位序输入 n个元素的值，建立带表头结点的单链表线性表L
{
LinkList p;
L=(LinkList)malloc(sizeof(LNode)); //生成头结点
L->next=NULL;
printf("请输入元素：");
for(int i=n;i>0;--i)
{
p=(LinkList)malloc(sizeof(LNode)); //生成新结点
scanf("%d",&p->data); //输入元素值
p->next=L->next; //插入到头结点之后
L->next=p;
}
}
//尾插法建表
void caudalList(LinkList &L,int n) //顺序建立单键表，尾插法
{
LinkList p,last;
L=(LinkList)malloc(sizeof(LNode)); //生成头结点
last=L; //注：定义指针变量后，一定要先赋值，再使用
printf("请输入元素：");
for(int i=n;i>0;--i)
{
p=(LinkList)malloc(sizeof(LNode)); //生成新结点
scanf("%d",&p->data); //输入元素值
last->next=p; //在last后插入p
last=p; //使用last指针指向最后一个结点
}
last->next=NULL;
}
//查找操作
int GetElem(LinkList &L,int i,ElemType &e) //L为带头结点的单链表的头指针
{ //当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
LinkList p;
p=L->next;
int j=1; //初始化p指向头结点，计数器j置1
while(p&&j<i) //顺指针向后查找，直到p指向第i个元素或p为空
{
p=p->next;
++j;
}
if(!p||j>i)
return ERROR; //第i<0或i>n时，表中无第i个结点
e=p->data; //取第i个元素
return OK;
}
//插入操作
int ListInsert(LinkList &L,int i,ElemType e) //在带头结点的单链线性表L的第i个元素之前插入元素e
{
LinkList s,p=L; //初始化
int j=0;
while(p&&j<i-1) //寻找第i-1个结点
{
p=p->next;
++j;
}
if(!p||j>i-1) //未找到，i<1或i>n+1
return ERROR;
s=(LinkList)malloc(sizeof(LNode)); //生成新结点
s->data=e;
s->next=p->next; //插入新结点
p->next=s;
return OK;
}
//删除操作
int ListDelete(LinkList &L,int i,ElemType &e) //在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
{
LinkList p=L,q;
int j=0;
while(p->next&&j<i-1) //寻找第i个结点，并令p指向其前驱(i-1)
{
p=p->next;
++j;
}
if(!(p->next)||j>i-1) //删除位置不合理
return ERROR;
q=p->next;
p->next=q->next; //删除结点
e=q->data;
free(q); //释放结点空间
return OK;
}
//统计单链表中值为x的元素的个数
int Count_x(LinkList L,ElemType x)
{
LinkList p;
p=L->next; //指针p指向单链表的第一个结点
int count=0; //计算器count清零
while(p!=NULL)
{
if(p->data==x)
count++; //若当前数据域为x，则计数器加1
p=p->next;
}
printf("值为x的元素的个数是：%d\n",count);
return count;
}
main()
{
LinkList L;
int n,m,a;
int e;
//InitList(L);
printf("请输入元素的个数：");
scanf("%d",&a);
//CreateList(L,a); //头插法
caudalList(L,a); //尾插法
printf("\nL=");
printf_L(L);
printf("请输入要插入元素的位置：");
scanf("%d",&n);
printf("请输入要插入元素的值:");
scanf("%d",&m);
ListInsert(L,n,m);
printf("插入后的元素为:");
printf_L(L);
printf("\n");
printf("请输入要删除元素的位置：");
scanf("%d",&n);
ListDelete(L,n,e);
printf("删除后的元素为：");
printf_L(L);
}