首页 > 代码库 > 数据结构线性单链表的算法实现和时间复杂度分析
数据结构线性单链表的算法实现和时间复杂度分析
#include<stdio.h>
#include<stdlib.h>
//线性表的动态分配链式存储结构
#define LIST_INIT_SIZE 100//线性表存储空间的初始分配量
#define LISTINCREMENT 10//线性表存储空间的分配增量
//函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;//Status是函数的类型，其值是函数结果状态代码
typedef int ElemType;
typedef struct LNode{//节点类型
ElemType data;
struct LNode *next;
}LNode,*LinkList;
//O(1)
Status InitList_L(LinkList &L)
{
//初始化一个有头节点的空的线性单链表L
L=(LinkList)malloc(sizeof(LNode));
if(!L) exit(OVERFLOW);
L->next=NULL;
return OK;
}//InitList_L
//O(n)
Status DestroyList_L(LinkList &L)
{
// 初始条件：线性表L已存在。
//操作结果：销毁线性表L为带头结点的链表，释放所有空间
while(L)
{
LinkList p=L;
L=L->next;
free(p);
}
printf("线性单链表销毁成功\n");
return OK;
}//DestroyList_L
//O(n)
Status ClearList_L(LinkList &L)
{
//初始条件：线性表L已存在。
//操作结果：将L重置为空表带头结点的链表，释放出头结点外的空间，保留头结点
LinkList p=L;
while(p->next)
{
LinkList q=p->next;
p->next=q->next;
free(q);
}
printf("线性单链表清空成功\n");
return OK;
}//ClearList_L
//O(1)
Status ListEmpty_l(LinkList &L)
{
//初始条件：线性表L已存在。
//操作结果：若L为空表，则返回TRUE，否则返回FALSE
LinkList p=L->next;
if(p)return TRUE;
return FALSE;
}//ListEmpty_l
//O(n)
Status LocateElem_L(LinkList L,ElemType e,Status (*compare)(ElemType,ElemType))
{
//初始条件：线性表L已存在。
//操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。若这样的数据元素不存在，则返回值为0
LinkList p=L->next;
int i=1;
while(p)
{
if((*compare)(p->data,e))
return i;
p=p->next;
++i;
}
return i;
}//LocateElem_L
Status compare(ElemType e1,ElemType e2)
{
if(e1==e2)
return OK;
else
return ERROR;
}
//O(n)
Status PriorElem_L(LinkList L,ElemType cur_e,ElemType &pre_e)
{
//初始条件：线性表L已存在。
//操作结果：若cue_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，否则操作失败，pre_e无定义
LinkList p=L->next;
while(p&&p->next)
{
if(p->next->data=http://www.mamicode.com/=cur_e)
{
pre_e=p->data;
return OK;
}
p=p->next;
}
return ERROR;
}//PriorElem_L
//O(n)
Status NextElem_L(LinkList L,ElemType cur_e,ElemType &next_e)
{
//初始条件：线性表L已存在。
//操作结果：若cue_e是L的数据元素，且不是最后一个，则用next_e返回它的后驱，否则操作失败，next_e无定义
LinkList p=L->next;
while(p&&p->next)
{
if(p->data=http://www.mamicode.com/=cur_e)
{
next_e=p->next->data;
return OK;
}
p=p->next;
}
return ERROR;
}//PriorElem_L
//O(n)
Status GetElem_L(LinkList L,int i,ElemType &e)
{
//L为带头节点的单链表的头指针
//当第i个元素存在时，其值赋给e并返回OK,否则返回ERROR
LinkList p=L->next; int j=1;//初始化，p指向第一个节点，j为计数器
while(p&&j<i)//顺指针向后查找，直到p指向第1个元素或p为空
{
p=p->next;
++j;
}
if(!p||j>i)return ERROR;//第i个元素不存在
e=p->data;//取第i个元素
return OK;
}//DestroyList_L
//O(n)
Status ListInsert_L(LinkList &L,int i,ElemType e)
{
//在带头结点的单链线性表中第i个位置之前插入元素e
LinkList p=L;int j=0;
while(p&&j<i-1)//寻找第i-1个节点
{
p->next;++j;
}
if(!p||j>i-1)return ERROR;//i小于1或者大于表长加1
LinkList s=(LinkList)malloc(sizeof(LNode));//生成新节点
s->data=http://www.mamicode.com/e;//插入到L中
s->next=p->next;
p->next=s;
return OK;
}//ListInsert_L
//O(n)
Status ListDelete_L(LinkList &L,int i,ElemType &e)
{
//在带头节点的单链表L中，删除第i个元素，并由e返回其值
LinkList p=L;int j=0;
while(p->next&&j<i-1)//寻找第i个结点，并令p指向其前驱
{
p=p->next;
++j;
}
if(!p->next||j>i-1)return ERROR;//删除位置不合理
LinkList q=p->next;//删除并释放结点
e=q->data;
p->next=q->next;
free(q);
return OK;
}//ListDelete_L
//O(n)
void CreateList_L(LinkList &L,int n)
{
//逆位序输入n个元素的值，建立带表结点的单链线性表L
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;//先建立一个带头节点的单链表
for(int i=n;i>0;--i)
{
LinkList p=(LinkList)malloc(sizeof(LNode));//生成新结点
//scanf("%d",&p->data);//输入元素值
p->data=http://www.mamicode.com/i;
p->next=L->next;//插入到表头
L->next=p;
}
}
//O(n)
Status ListTraverse_L(LinkList &L,Status (*visit)(ElemType))
{
//初始条件：线性表L已存在
//操作结果:依次对L的每个元素调用，visit().一旦visit()失败，则操作失败。
LinkList p=L->next;
printf("单链线性表中的元素依次为:");
while(p)
{
if((*visit)(p->data))
printf("%d,",p->data);
else
return ERROR;
p=p->next;
}
}//ListTraverse_L
Status visit(ElemType e)
{
return OK;
}
//O(La.length+Lb.length)
void mergelist_L(LinkList &La,LinkList &Lb,LinkList &Lc)
{
//已知单链线性表La和Lb的元素按值非递减排列
//归并La和Lb得到新的单链线性表Lc，Lc的元素也按值非递减排列
LinkList pa=La->next,pb=Lb->next;
LinkList pc;
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:pc->next=pb;
free(Lb);
}//mergelist_L
int main()
{
LinkList La,Lb,Lc;
int n=4,i=1;
ElemType pre_e,next_e;
CreateList_L(La,n);
CreateList_L(Lb,n);
ListTraverse_L(La,visit);
printf("\n");
ListTraverse_L(Lb,visit);
printf("\n");
mergelist_L(La,Lb,Lc);
ListInsert_L(Lc,2,1);
ListDelete_L(Lc,2,i);
ListTraverse_L(Lc,visit);
printf("线性单链表中2的元素位序为:%d\n",LocateElem_L(Lc,2,compare));
PriorElem_L(Lc,2,pre_e);
printf("线性单链表中2的元素前驱为:%d\n",pre_e);
NextElem_L(Lc,2,next_e);
printf("线性单链表中2的元素后继为:%d\n",next_e);
ClearList_L(Lc);
ListTraverse_L(Lc,visit);
printf("\n");
DestroyList_L(La);
getchar();
getchar();
return 0;
}
数据结构线性单链表的算法实现和时间复杂度分析