线性表的链式表示与实现

#include<iostream>
#include<malloc.h>
using namespace std;

typedef int ElemType;
typedef int Status;
#define OK 1
#define ERROR 0

typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList;

/*逆位序输入n个元素的值，建立带表头结点的单链线性表L*/
void CreateList_L(LinkList &L,int n)
{
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
for(int i=0;i!=n;i++)
{
LinkList p=(LinkList)malloc(sizeof(LNode));
cin>>p->data;
p->next=L->next;
L->next=p;
}
}

/*当第i个元素存在时，其值赋给e并返回ok，否则返回error*/
Status GetElem_L(LinkList &L,int i,ElemType &e)
{
LinkList p=L->next;
int n=1;
while(n!=i&& p!=NULL)
{
p=p->next;
n++;
}
if(!p) return ERROR;
e=p->data;
return OK;
}

/*在带头结点的单链表中，删除第i个元素，并由e返回其值*/
Status ListDelete_L(LinkList &L,int i,ElemType &e)
{
LinkList p=L->next;
LinkList q=L;
int k=1;
while(p!=NULL && k!=i)
{
k++;
q=p;
p=p->next;

}
if(p==NULL) return ERROR;
e=p->data;
q->next=p->next;
free(p);
return OK;
}

/*将两个有序链表合并为一个有序链表*/
/*La和Lb的元素按值非递减排列*/
/*在归并两个链表为一个链表时，不需要另建新表的结点空间，而只需要
将原来两个链表中的结点之间的关系解除，重新按元素值非递减的关系将所有结点连接成一个链表即可*/
void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc)
{
LinkList pa=La->next;
LinkList pb=Lb->next;
LinkList pc=La;
Lc=pc;
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;
}
}
if(pa) pc->next=pa;
if(pb) pc->next=pb;
}

void print(LinkList &L)
{
LinkList p=L->next;
cout<<"头指针L->头结点->";
while(p!=NULL)
{
cout<<p->data<<"->";
p=p->next;
}
cout<<"NULL"<<endl;
}

int main(){
/*cout<<"逆序创建一个链表,input n:";
int n;
cin>>n;
LinkList L;
CreateList_L(L,n);
print(L);
ElemType e;
if(GetElem_L(L,3,e))
cout<<e<<endl;
else
cout<<"doesn't exist!"<<endl;

cout<<"删除链表L的第3个位置的元素：";
if(ListDelete_L(L,3,e))
{

cout<<e<<endl;
cout<<"删除之后为：";
print(L);
}
else
cout<<"doesn't exist!"<<endl;*/
int n;
cout<<"逆序创建一个链表(非递减),input n:";
cin>>n;
LinkList L1;
CreateList_L(L1,n);
print(L1);
cout<<"逆序创建一个链表(非递减),input n:";
cin>>n;
LinkList L2;
CreateList_L(L2,n);
print(L2);
cout<<"合并前面两个链表(非递减),input :";
LinkList L3;
MergeList_L(L1,L2,L3);
print(L3);

return 0;
}

#include<iostream>
#include<malloc.h>
using namespace std;

typedef int ElemType;
typedef int Status;
#define OK 1
#define ERROR 0
#define MAX_SIZE 100

/*-------线性表的静态单链表存储结构----------*/
typedef struct{
ElemType data;
int cur;
}component,SLinkList[MAX_SIZE];

/*为了辨明数组中哪些分量未被使用，解决的办法是将所有未被使用过以及被删除的分量
用游标链成一个备用的链表，每当进行插入时，便可从备用链表上取得第一个结点作为待插入的新结点
反之，在删除时将从链表中删除下来的结点链接到备用链表上*/

/*将整个数组空间初始化成一个链表*/
void InitSpace_SL(SLinkList &space)
{
/*将一维数组space中各分量链成一个备用链表，space[0].cur为头指针，0表示空指针*/
for(int i=0;i!=MAX_SIZE-1;i++)
space[i].cur=i+1;
space[MAX_SIZE-1].cur=0;
}

int Malloc_SL(SLinkList &space)
{
/*若备用空间链表非空，则返回分配的结点下标，否则返回0*/
int i=space[0].cur;
if(space[0].cur)
space[0].cur=space[i].cur;/*记录备用空链表的第一个结点*/
return i;
}

void Free_SL(SLinkList &space,int k)
{
/*将下标为k的空闲结点回收到备用链表*/
space[k].cur=space[0].cur;
space[0].cur=k;
}

void CreateList_SL(SLinkList &space,int n)
{
InitSpace_SL(space);
int S=Malloc_SL(space);//生成头结点
int r=S;//r指向S的当前最后结点
int m;
for(int i=0;i!=n;i++)
{
m=Malloc_SL(space);
cin>>space[m].data;
space[r].cur=m;
r=m;
}
space[r].cur=0;
}

/*在静态单链线性表L中，查找第1个值为e的元素
若找到，则返回它在L中的位序，否则返回0.*/
int LocateElem_SL(SLinkList space,ElemType e)
{
int i=space[1].cur;
while(i && space[i].data!=e)
i=space[i].cur;
if(i==0)
return 0;
return i-1;
}

void print_SL(SLinkList space)
{
int i=space[1].cur;
while(i)
{
cout<<space[i].data<<"->";
i=space[i].cur;
}
cout<<"NULL"<<endl;
}

/*删除一个指定位置的元素*/
Status SListDelete_SL(SLinkList &space,int i,ElemType &e)
{
int k=space[1].cur;
int r=k-1;
int count=1;
while(k && count!=i)
{
r=k;
k=space[k].cur;
count++;
}
if(k==0)
return ERROR;
e=space[k].data;
space[r].cur=space[k].cur;
Free_SL(space,k);
return OK;
}

/*在指定的位置插入元素*/
Status SListInsert_SL(SLinkList &space,int i,ElemType e)
{
int k=space[1].cur;
int count=1;
int r=k-1;
while(k && count!=i)
{
r=k;
k=space[k].cur;
count++;
}
if(k==0)
return ERROR;
int t=Malloc_SL(space);
space[t].data=e;
space[r].cur=t;
space[t].cur=k;
return OK;
}

int main(){
SLinkList space;
cout<<"请输入4个整数：";
CreateList_SL(space,4);
print_SL(space);
cout<<"在上述链表中，找到第一个等于2的数的位置：";
int t;
if(t=LocateElem_SL(space,2))
cout<<t<<endl;
else
cout<<"不存在!"<<endl;
cout<<"将上述位置的元素删除后：";
int e;
if(SListDelete_SL(space,t,e))
print_SL(space);
else
cout<<"ERROR!"<<endl;
cout<<"将该删除的元素还原后：";
if(SListInsert_SL(space,t,e))
print_SL(space);
else
cout<<"ERROR!"<<endl;
return 0;
}

#include<iostream>
#include<stdlib.h>

using namespace std;

typedef int ElemType;
typedef int Status;
#define OK 1
#define ERROR 0
#define MAX_SIZE 100

/*---------线性表的双向链表存储结构-------*/
typedef struct DuLNode{
ElemType data;
struct DuLNode *prior;
struct DuLNode *next;
}DuLNode,*DuLinkList;

/*创建双向链表*/
void CreateDuL(DuLinkList &L,int n)
{
L=(DuLinkList)malloc(sizeof(DuLinkList));
L->prior=L;
L->next=L;
DuLinkList t,p;
p=L;
for(int i=0;i!=n;i++)
{
t=(DuLinkList)malloc(sizeof(DuLinkList));
cin>>t->data;
p->next=t;
L->prior=t;
t->prior=p;
t->next=L;
p=t;
}
}

/*在带头结点的双链循环线性表L中第i个位置之前插入元素e*/
Status ListInsert_DuL(DuLinkList &L,int i,ElemType e)
{
DuLinkList p=L->next;
int count=1;
while(p!=L && count!=i)
{
p=p->next;
count++;
}
if(count==i)
{
DuLinkList t=(DuLinkList)malloc(sizeof(DuLinkList));
t->data=e;
t->next=p;
t->prior=p->prior;
p->prior->next=t;
p->prior=t;
return OK;
}
return ERROR;
}

/*删除带头结点的双链循环线性表L的第i个元素*/
Status ListDelete_DuL(DuLinkList &L,int i,ElemType &e)
{
DuLinkList p=L->next;
int count=1;
while(p!=L && count!=i)
{
count++;
p=p->next;
}
if(p==L)
return ERROR;
e=p->data;
p->prior->next=p->next;
p->next->prior=p->prior;
//free(p);/*----------free的时候出错，留待以后解决--------------*/
return OK;
}

/*输出双向链表*/
void print_DuL(DuLinkList L)
{
DuLinkList p=L->next;
cout<<"L->头结点->";
while(p!=L)
{
cout<<p->data<<"->";
p=p->next;
}
cout<<"NULL"<<endl;
}

int main(){
DuLinkList L;
cout<<"输入4个整数：";
CreateDuL(L,4);
cout<<"输出链表：";
print_DuL(L);

//	cout<<"在位置3之前，插入元素3后的链表为:";
//	ListInsert_DuL(L,3,3);
cout<<"在位置5之前，插入元素5后的链表为:";
ListInsert_DuL(L,5,5);
print_DuL(L);

cout<<"删除上述操作后:";
ElemType e;
if(ListDelete_DuL(L,5,e))
print_DuL(L);
else
cout<<"ERROR!"<<endl;
return 0;
}