链表是链式存储的线性表。一般讨论的是带头节点的链表(优点是不需要额外讨论首元节点的操作,空表和非空表统一处理)
1.查找O(N)--顺序存取
2.删除,插入O(1)(不计算找位置的过程),但对于单链表仍然是O(N)
#include<stdio.h>
#include<malloc.h>
#define OK 1
#define ERROR 0
#define Status int
/*
链表是链式存储的线性表。一般讨论的是带头节点的链表(优点是不需要额外讨论首元节点的操作,空表和非空表统一处理)
1.查找O(N)--顺序存取
2.删除,插入O(1)(不计算找位置的过程),但对于单链表仍然是O(N)
*/
typedef struct{
int value;
}ElemType;
struct Lnode{
ElemType e;
struct Lnode *next;
};
typedef struct Lnode LNode,*LinkList;
//1.初始化
Status ListInit(LinkList &L){
L=(LNode*)malloc(sizeof(LNode));
L->next=NULL;
return OK;
}
//2.单链表头插法,(这只是插入一个元素)建立一个链表需要O(N);与此类似,尾插法也是O(N)
Status InsertFromHead(LinkList &L, ElemType e){
LNode *node=(LNode*)malloc(sizeof(LNode));
node->e=e;
//注意空表的情况
if (!L->next)
{
L->next=node;
node->next=NULL;//这句话一定记住了!!
}else{
//经典操作 或者LNode *p=L->next;node->next=p;L->next=node;
node->next=L->next;
L->next=node;
}
return OK;
}
//3.求表长n, O(N)
int ListLength(LinkList L){
int count=0;
LNode *p;
p=L->next;
while (p)
{
p=p->next;
count++;
}
return count;
}
//4.***按值查找,返回序号 O(N)
/*
应试:
int LocateElem(LinkList L,ElemType e){
LNode *p=L->next;
int index=1;
while (p && p->e!=e) //不等于不需要写方法判断
{
p=p->next;
index++;
}
if (p) return index;
else return 0;
}
*/
int equal(ElemType a, ElemType b){
return a.value==b.value?1:0;
}
int LocateElem(LinkList L,ElemType e){
LNode *p=L->next;
int index=1;
while (p && !equal(p->e,e))
{
p=p->next;
index++;
}
if (p) return index;
else return 0;
}
//5.***按序号查找,返回在ElemType中,认真体会 O(N)
Status GetElem(LinkList L,int pos,ElemType &e){
if (pos<1) return ERROR;//或者这句话不用写
LNode *p=L->next;
int index=1;
while (p && index<pos)
{
p=p->next;
index++;
}
if (!p) return ERROR; //或者if(!p||j>i) return ERROR;
e=p->e;
return OK;
}
//6.***在第i给元素之前插入元素e, 对于单链表来说需要找到结点,所以是O(N),但对于其他的链表来说可以是O(1)
Status ListInsert(LinkList &L,int i,ElemType e){
//先找到第i-1个结点
LNode *p=L->next;
int index=1;
while(p && index<i-1){
p=p->next;
index++;
}
if (!p || index>i-1) return ERROR;
//现在p指向的就是第i-1个节点
LNode *node=(LNode*)malloc(sizeof(LNode));
node->e=e;
//重要操作!!
node->next=p->next;
p->next=node;
return OK;
}
//7.***删除第i个元素,对于单链表来说需要找到结点,所以是O(N),但对于其他的链表来说可以是O(1)
Status ListDelete(LinkList &L, int i, ElemType &e){
//先寻找第i-1个节点
//先找到第i-1个结点
LNode *p=L->next;
int index=1;
while(p && index<i-1){
p=p->next;
index++;
}
if (!p || index>i-1) return ERROR;
//现在p指向的就是第i-1个节点
LNode *q=p->next;//指向第i个
p->next=p->next->next;
e=q->e;
delete(q);
return OK;
}
int ListEmpty(LinkList L){
if (L->next)//非空《==》L->next!=null,简写需要记住
return 0;
else return 1;
}
Status ClearList(LinkList L){
LNode *p,*q;
p=L->next;
while (p)
{
q=p->next;
delete(p);
p=q;
}
L->next=NULL;
return OK;
}
void show(LinkList L){
LNode *p=L->next;
while (p)
{
printf("%d-",p->e.value);
p=p->next;
}
printf("\n");
}
//test
int main(){
LinkList L;
ListInit(L);
ElemType e[10];
for (int i = 0; i < 10; i++)
{
e[i].value=i;
InsertFromHead(L,e[i]);
}
//测试头插法
show(L);
//测试按值查找
printf("查找得到的位置为%d\n",LocateElem(L,e[0]));
//测试按位查找
GetElem(L,1,e[0]);
printf("查找得到的值为%d\n",e[0].value);
//测试插入元素
ListInsert(L,5,e[0]);
show(L);
//测试删除元素
ListDelete(L,5,e[0]);
show(L);
}