㈠ 數據結構，線性表中刪除某個元素為什麼還要把這個元素賦值給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);
}