目录
定义
线性表的链式存储成为单链表。
优点：不要求大片连续空间，改变容量方便
缺点：不可随机存取，要耗费一定空间存放指针
单链表的实现
typedef struct LNode{ //定义单链表结点类型
int data; //每个节点存放一个数据元素
struct LNode *next; //指针指向下一个节点
}LNode,*LinkList;要表示一个单链表时，只需要声明一个头指针L，指向单链表的第一个结点。
//声明一个指向单链表第一个结点的指针
LNode * L； //强调这是一个结点
LinkList L； //强调这是一个单链表不带头结点
#include<stdio.h>
typedef struct LNode{ //定义单链表结点类型
int data; //每个节点存放一个数据元素
struct LNode *next; //指针指向下一个节点
}LNode,*LinkList;
//初始化一个空的单链表
bool InitList(LinkList &L){
L = NULL; //空表，暂时还没有任何结点
return true;
}
int main(){
LinkList L; //声明一个指向单链表的指针
//初始化一个空表
InitList(L);
return 0;
} 带头结点
#include<stdio.h>
typedef struct LNode{ //定义单链表结点类型
int data; //每个节点存放一个数据元素
struct LNode *next; //指针指向下一个节点
}LNode,*LinkList;
//初始化一个单链表（带头结点）
bool InitList(LinkList &L){
L = (LNode *) malloc(sizeof(LNode)); //分配一个头结点
if(L == NULL) //内存不足，分配失败
return false;
L->next = NULL; //头结点之后暂时还没有节点
return true;
}
int main(){
LinkList L; //声明一个指向单链表的指针
//初始化一个空表
InitList(L);
return 0;
} 不带头结点，写代码更麻烦
对第一个数据结点和后续数据结点的处理需要用不同的代码逻辑
对空表和非空表的处理需要用不同的代码逻辑
单链表的判空（Empty)
不带头结点
//判断单链表是否为空
bool Empty(LinkList L){
if(L == NULL);
return true;
else
return false;
}//判断单链表是否为空
bool Empty(LinkList L){
return (L==NULL);
}带头结点
//判断单链表是否为空
bool Empty(LinkList L){
if(L->next == NULL);
return true;
else
return false;
}//判断单链表是否为空
bool Empty(LinkList L){
return (L->next == NULL);
}单链表的位序插入（ListInsert)
不带头结点
//在第i个位置插入元素e（不带头结点）
bool ListInsert(LinkList &L,int i, int e){
if(i<1)
return false;
if(i==1){ //插入第1个结点的操作与其他结点操作不同
LNode *s = (LNode *) malloc(sizeof(LNode));
s->data = e;
s->next= L;
L = s; //头指针指向新结点
return true;
}
LNode *p; //指针p指向当前扫描到的结点
int j = 1; //当前p的位序
p = L; //p指向第1个结点(注意：不是头结点））
while(p!=NULL && j<i-1){//循环找到第 i-1 个结点
p=p->next;
j++;
}
if(p==NULL) //i值不合法
return false;
LNode *s = (LNode *) malloc(sizeof(LNode));
s->data = e;
s->next=p->next;
p->next = s; //将结点s连到p之后
return true; //插入成功
}带头结点
//在第i个位置插入元素e（带头结点）
bool ListInsert(LinkList &L,int i, int e){
if(i<1)
return false;
LNode *p; //指针p指向当前扫描到的结点
int j = 0; //当前p的位序
p = L; //L指向头结点，头结点是第0个结点（不存数据)
while(p!=NULL && j<i-1){//循环找到第 i-1 个结点
p=p->next;
j++;
}
if(p==NULL) //i值不合法
return false;
LNode *s = (LNode *) malloc(sizeof(LNode));
s->data = e;
s->next=p->next;
p->next = s; //将结点s连到p之后
return true; //插入成功
}最好时间复杂度：O(1)
最坏时间复杂度：O(n)
平均时间复杂度：O(n)
指定结点的后插操作（InsertNextNode)
//后插操作：在p结点之后插入元素e
bool InsertNextNode(LNode *p,int e){
if(p==NULL)
return false;
LNode *s = (LNode *) malloc(sizeof(LNode));
if(s==NULL) //内存分配失败
return false;
s->data = e; //用结点s保存数据元素e
s->next=p->next;
p->next = s; //将结点s连到p之后
return true;
}时间复杂度：O(1)
指定结点的前插操作（InsertPriorNode)
//前插操作：在p结点之前插入元素e
bool InsertPriorNode(LNode *p,int e){
if(p==NULL)
return false;
LNode *s = (LNode *) malloc(sizeof(LNode));
if(s==NULL) //内存分配失败
return false;
s->next = p->next;
p->next = s; //将结点s连到p之后
s->data = p->data; //将p中元素复制到s中
p->data = e; //p中元素覆盖为e
return true;
}时间复杂度：O(1)
单链表的位序删除（ListDelete)
不带头结点
bool ListDelete(LinkList &L， int i ,int &e){
if(i<1)
return false;
if(i==1){ //删除第1个结点的操作与其他结点操作不同
LNode *p;
p = L;
e = p->next->data;
p->next->data = null;
L = p->next; //头指针指向新结点
return true;
}
LNode *p; //指针p指向当前扫描到的结点
int j = 0; //当前p的位序
p = L; //L指向头结点，头结点是第0个结点（不存数据)
while(p!=NULL && j<i-1){//循环找到第 i-1 个结点
p=p->next;
j++;
}
if(p==NULL) //i值不合法
return false;
if(p->next==NULL) //第i-1个结点之后已无其他结点
return false;
LNode *q = p->next; //令q指向被删除结点
e = q->data; //用e返回元素的值
p->next = q->next; //将*q结点从链中"断开"
free(q); //释放结点的存储空间
return true; //删除成功
}带头结点
bool ListDelete(LinkList &L， int i ,int &e){
if(i<1)
return false;
LNode *p; //指针p指向当前扫描到的结点
int j = 0; //当前p的位序
p = L; //L指向头结点，头结点是第0个结点（不存数据)
while(p!=NULL && j<i-1){//循环找到第 i-1 个结点
p=p->next;
j++;
}
if(p==NULL) //i值不合法
return false;
if(p->next==NULL) //第i-1个结点之后已无其他结点
return false;
LNode *q = p->next; //令q指向被删除结点
e = q->data; //用e返回元素的值
p->next = q->next; //将*q结点从链中"断开"
free(q); //释放结点的存储空间
return true; //删除成功
}最好时间复杂度：O(1)
最坏时间复杂度：O(n)
平均时间复杂度：O(n)
指定结点的删除操作（DeleteNode)
//删除指定结点p
bool DeleteNode(LNode *p){
if(p==NULL)
return false;
LNode *q = p->next; //令q指向*p的后继结点
p->data = p->next->data;//和后继结点交换数据域
p->next = q->next; //将*q结点从链中"断开"
free(q); //释放结点的存储空间
return true;
}时间复杂度：O(1)
单链表的按位查找(GetElem)
//按位查找，返回第i个元素（带头结点）
LNode * GetElem(LinkList L,int i){
if(i<1)
return NULL;
LNode * p; //指针p指向当前扫描到的结点
int j = 0; //p的位序
p = L; //L指向头结点，头结点是第0个结点（不存数据）
while(p!=NULL && j<i) { //循环找到第i个结点
p=p->next;
j++;
}
return p;
}时间复杂度：O(n)
单链表的按值查找(LocateElem)
//按值查找，找到数据域==e的结点
LNode * LocateElem(LinkList L,int e){
LNode *p = L->next;
//从第1个结点开始查找数据域为e的结点
while (p!=NULL && p->data !=e)
p = p->next;
return p; //找到后返回该结点指针，否则返回NULL
}时间复杂度：O(n)
单链表的长度(Length)
//求表的长度 (带头结点）
int Length(LinkList L){
int len = 0; //统计表长
LNode *p =L;
while (p->next != NULL){
p->next;
len++;
}
return len;
}时间复杂度：O(n)
单链表的建立
尾插法
//尾插法（带头结点）
LinkList ListI_TailInsert(LinkList &L){
int x;
L=(LinkList)malloc(sizeof(LNode)); //建立头结点
LNode *s,*r = L; //r为表尾指针
scanf("%d",&x); //输入结点的值
while(x!=9999){ //输入9999表示结束
s=(LNode)malloc(sizeof(LNode));
s->data =x;
r->next=s;
r = s; //r指向新的表尾结点
scanf("%d",&x);
}
r->next=NULL; //尾结点指针置空
return L;
}时间复杂度：O(n)
头插法
//头插法（带头结点）
LinkList ListI_HeadInsert(LinkList &L){
LNode *s;
int x;
L=(LinkList)malloc(sizeof(LNode)); //建立头结点
L->next=NULL; //初始为空链表
scanf("%d",&x); //输入结点的值
while(x!=9999){ //输入9999表示结束
s=(LNode)malloc(sizeof(LNode)); //创建新结点
s->data = x;
s->next = L->next;
L->next = s; //将新结点插入表中，L为头结点
scanf("%d",&x);
}
return L;
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
