线性表——表

一表的性质

1.类型名称：表（List）：

数据对象的特征：

   有序性：有n个元素构成的有序序列。依赖性：元素之间一对一的相互依赖的邻接逻辑关系。

操作集： 略      

物理储存实现：

数组：对于Find 时间复杂度为常数

           对于插入删除时间比较慢

          由于问题规模无法确定，要预留空间方便后边操作

链表：所有的基本操作时间复杂度为n

           对于空间大小不关心

           要进行malloc free等内存管理 要比数组要慢。

综上所诉 ：如果主要功能为Find 选择数组，否则链表，但是如果要均衡时间与空间的重要程度，要另外做出均衡。

二。表的实现

一 链式实现（带头结点）：

#include<stdio.h>
#include<stdlib.h>
typedef int ElementType;
struct Node{
union{
int size;
ElementType data;
}UData; //数据域

struct Node * pNext;//指针域

};
typedef struct Node *List;//指向头结点
typedef struct Node *Position;//指向任意一个节点
//-----------------------------------------------------
//-----------------------------------------------------
List CreateList(void);//创建一个空表
void DisposeList(List L);//销毁一个表
Position CreateNode(ElementType data);//创建一个节点

void ShowList(List L);//显示一个表

bool Insert(List L,ElementType X );//增加节点
bool DeleteAll(List L,ElementType X );//删除所有的X节点
Position Find(List L,ElementType X);//查找X节点

List InverseList(List L);// 反转链表
List CombineList(List L,List L2);//合并两个链表
//-----------------------------------------------------
//-----------------------------------------------------
List CreateList(void)//创建一个空表
{
List L;
L=(List)malloc(sizeof(struct Node));
if(L==NULL) return NULL;
L->UData.size=0;
L->pNext=NULL;

return L;
}
void DisposeList(List L)//销毁一个表
{
if(L==NULL) return ;
Position ptemp=L->pNext;
while(ptemp!=NULL)
{
Position t=ptemp->pNext;
free(ptemp);
ptemp=t;
}
}
Position CreateNode(ElementType data)//创建一个节点
{
Position pNew;
pNew=(Position)malloc(sizeof(struct Node));
if(pNew==NULL) return NULL;
pNew->UData.data=data;
pNew->pNext=NULL;

return pNew;
}

void ShowList(List L)//显示一个表
{
if(L==NULL) return ;
Position ptemp=L->pNext;
while(ptemp!=NULL)
{
printf("%d\t%p\t%p\t\n",ptemp->UData.data,ptemp,ptemp->pNext);
ptemp=ptemp->pNext;
}
printf("\n\n");
printf("size: %d\n",L->UData.size);
printf("\n\n");
}

bool Insert(List L,ElementType X )//增加节点
{
if(L==NULL) return false;
Position pNew=CreateNode(X);
Position p1=L,p2=L->pNext;
while(p2!=NULL&&p2->UData.data<X)
{
p1=p2;
p2=p2->pNext;
}
pNew->pNext=p1->pNext;
p1->pNext=pNew;
L->UData.size++;
return true;
}
bool DeleteAll(List L,ElementType X )//删除所有的X节点
{
if(L==NULL) return false;
Position p1=L,p2=L->pNext;
while(p2!=NULL)
{
if(p2->UData.data==X)
{
p1->pNext=p2->pNext;
free(p2);
L->UData.size--;
p2=p1->pNext;
}
else
{
p1=p2;
p2=p2->pNext;
}
}
return true;
}
Position Find(List L,ElementType X)//查找X节点
{
Position ptemp=L->pNext;
while(ptemp!=NULL)
{
if(ptemp->UData.data==X)
{
return ptemp;
}
ptemp=ptemp->pNext;
}
return NULL;
}

List InverseList(List L)// 反转链表
{
if(L==NULL) return NULL;
Position q=NULL,ptemp=L->pNext,t=NULL;
while(ptemp!=NULL)
{
t=ptemp->pNext;

ptemp->pNext=q;

q=ptemp;
ptemp=t;
}
L->pNext=q;
return L;
}
List CombineList(List L,List L2)//排好序的两个链表合并两个链表
{

List ComList=CreateList();
ComList->UData.size=L->UData.size+L2->UData.size;
Position i=L->pNext,j=L2->pNext;
Position ptemp=ComList;
while(i!=NULL&&j!=NULL)
{
if(i->UData.data<j->UData.data)
{
ptemp->pNext=i;
i=i->pNext;

}
else
{
ptemp->pNext=j;
j=j->pNext;

}
ptemp=ptemp->pNext;
}
if(i==NULL)
{
ptemp->pNext=j;
}
else
if(j==NULL)
{
ptemp->pNext=i;
}
return ComList;
}
//--------------------------------------------------------
//--------------------------------------------------------
int main (void)
{
List L = CreateList();
Insert(L,2 );
Insert(L,12 );
Insert(L,2 );
Insert(L,45 );
Insert(L,2 );
Insert(L,67 );
Insert(L,2 );
Insert(L,59 );
Insert(L,89);
ShowList(L);

DeleteAll(L,2 );
DeleteAll(L,15 );
DeleteAll(L,89 );
DeleteAll(L,-89);
ShowList(L);
//Position Find(List L,ElementType X);
L=InverseList(L);
ShowList(L);

List L2 = CreateList();
Insert(L2,-2 );
Insert(L2,-12 );
Insert(L2,-2 );
Insert(L2,45 );
Insert(L2,-2 );
Insert(L2,-67 );
Insert(L2,-2 );
Insert(L2,-59 );
Insert(L2,89);
ShowList(L2);

List L3=CombineList(L,L2);
ShowList(L3);

return 0;
}

二顺序表实现：

#include<stdio.h>
#include<stdlib.h>
typedef int ElementType;
typedef int Position;
struct Node {
ElementType *Array;
Position Last;
};
typedef struct Node List;

List *MakeEmpty(int MaxSize);
void DeleteList(List* L);
void add(List *L, ElementType X);

void Find(ElementType X, List* L, Position Po[]);
void Insert(ElementType X, Position i, List* L);
void Delete(Position i, List* L);

int Length(List* L);


List *MakeEmpty(int MaxSize)
{
List *L;
L = (List*)malloc(sizeof(List));
if (L == NULL) return NULL;
L->Array = (ElementType*)malloc(sizeof(ElementType)*MaxSize);
if (L->Array == NULL) return NULL;
L->Last = -1;

return L;
}
void DeleteList(List* L)
{
if (L == NULL) return;
if (L->Array != NULL) free(L->Array);
free(L);
}

void add(List *L, ElementType X)
{
L->Array[(L->Last)+1] = X;
L->Last+=1;
}


void Find(ElementType X, List* L,Position Po[])
{
if (L == NULL) return;
int i = 0,j=0;
while (i <= L->Last)
{
if (L->Array[i] == X)
{
Po[j] = i;
j++;
}
i++;
}
}
void Insert(ElementType X, Position i, List* L)
{
int j;
if (L->Last == 20 - 1) return;
if (i<1 || i>L->Last + 2) return;
for ( j = L->Last; j >=i; j--)
{
L->Array[j + 1] = L->Array[j];
}
L->Array[i - 1] = X;
L->Last++;
return;
}
void Delete(ElementType X, List* L)
{
if (L == NULL) return;
int i = 0;
while (i <= L->Last)
{
if (L->Array[i] == X)
{
for (int j = i; j < L->Last; j++)
{
L->Array[j] = L->Array[j + 1];
}
L->Last--;
i = 0;
continue;
}
i++;
}
}

int main(void)
{
List * L;
L = MakeEmpty(10);
add(L, 1);
add(L, 3);
add(L, 4);
add(L, 1);
add(L, 3);
add(L, 9);
add(L, 1);
add(L, 6);
Position Po[10] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
/*Find(1, L, Po);
for (int i = 0;i<10 ; i++)
{
if (Po[i] != -1)
{
printf("%d ", Po[i]);
}
}*/
Delete(1, L);
int i = 0;
while (i <= L->Last)
{
printf("%d ", L->Array[i]);
i++;
}
system("pause");
return 0;
}

三 静态链表（内存管理）

//静态链表实现
//====================================================
#include<stdio.h>

#define MaxSize 100
#define null 0
typedef int ElementType;
typedef int Position;
struct Node {
union{
ElementType data;
int size;
}UData;
Position pNext;
};
struct Node Space[MaxSize];
typedef int List;
//=====================================================
void init(void);//初始化
Position Malloc(void);//分配一份空间
void Free(Position p);//收回一份空间

Position CreateList(void);
void Disope(List L);
void Show(List L);

Position CreateNode(ElementType X);
void Insert(List L,ElementType X);
void DeleteAll(List L,ElementType X);
Position Find(List L,ElementType X);
//=====================================================
void init(void)//初始化
{
Position i=0;
while(i<MaxSize-1)
{
Space[i].pNext=i+1;
i++;
}
Space[i].pNext=null;
}
Position Malloc(int size)//分配一份空间
{
Position t=Space[0].pNext;
Space[0].pNext=Space[t].pNext;
return t;
}
void Free(Position p)//收回一份空间
{
Space[p].pNext=Space[0].pNext;
Space[0].pNext=p;
}

Position CreateList(void)
{
List L;
L=Malloc(sizeof(ElementType));

if(L==null) return null;
Space[L].pNext=null;
Space[L].UData.size=0;
return L;
}
void Disope(List L)
{
Position ptemp=Space[L].pNext,t;
while(ptemp!=null)
{
t=Space[ptemp].pNext;
Free(ptemp);
ptemp=t;
}
}
void Show(List L)
{
Position ptemp=Space[L].pNext;
while(ptemp!=null)
{

printf("%d\t%d\t%d\t\n",Space[ptemp].UData.data,ptemp,Space[ptemp].pNext);
ptemp=Space[ptemp].pNext;
}
printf("\n");
}

Position CreateNode(ElementType X)
{
Position pNew;
pNew=Malloc(sizeof(ElementType));
Space[pNew].pNext=null;
Space[pNew].UData.data=X;
return pNew;
}
void Insert(List L,ElementType X)
{
Position pNew=CreateNode(X);
Position p1=L,p2=Space[L].pNext;
while(p2!=null&&Space[p2].UData.data<X)
{
p1=p2;
p2=Space[p2].pNext;
}
Space[pNew].pNext=Space[p1].pNext;
Space[p1].pNext=pNew;
Space[L].UData.size++;
}
void DeleteAll(List L,ElementType X)
{
if( L==null && Space[L].pNext==null ) return ;
Position p1=L,p2=Space[L].pNext;
while(p2!=null)
{
if(Space[p2].UData.data==X)
{
Space[L].UData.size--;
Space[p1].pNext=Space[p2].pNext;
Free(p2);
p2=Space[p1].pNext;
}
else
{
p1=p2;
p2=Space[p2].pNext;
}
}
}
Position Find(List L,ElementType X)
{
Position ptemp=Space[L].pNext;
while(ptemp!=null)
{
if(Space[ptemp].UData.data==X)
{
return ptemp;
}
ptemp=Space[ptemp].pNext;
}
}
//=====================================================
int main (void)
{
init();
List L= CreateList();

Insert( L,3);
Insert( L,32);
Insert( L,235);
Insert( L,4);
Insert( L,56);
Insert( L,3);
Insert( L,3);
Insert( L,3);
Show( L);
DeleteAll(L,3);
DeleteAll(L,235);
DeleteAll(L,56);
DeleteAll(L,4);
DeleteAll(L,32);
Show( L);


return 0;
}

四 循环链表

#include<stdio.h>
#include<stdlib.h>

struct Node
{
int data;
struct Node *pNext;
};

typedef struct Node node;

node *add_node(int data);
node *add_back(node *phead, int data);
node *add_head(node *phead, int data);

void showall(node *phead);

node *Findfirst(node *phead, int data);

node *Delete(node *phead, int data);

node *Insert(node *phead, int data);


node *add_node(int data)
{
node *p = (node *)malloc(sizeof(node));
if (p != NULL)
{
p->data = data;
p->pNext = NULL;
}
return p;
}
node *add_back(node *phead, int data)
{
node *pNew = add_node(data);
if (phead == NULL)
{
phead = pNew;
pNew->pNext = phead;
}
else
{
node *ptemp = phead;
while (ptemp->pNext != phead)
{
ptemp = ptemp->pNext;
}
pNew->pNext = ptemp->pNext;
ptemp->pNext = pNew;

}
return phead;
}
node *add_head(node *phead, int data)
{
node *pNew = add_node(data);
if (phead == NULL)
{
phead = pNew;
pNew->pNext = phead;
}
else
{
node *ptemp = phead;
while (ptemp->pNext != phead)
{
ptemp = ptemp->pNext;
}
ptemp->pNext = pNew;
pNew->pNext = phead;
phead = pNew;

}
return phead;
}



void showall(node *phead)
{
if (phead == NULL)
{
return;
}
else
{
node *p = phead;
if (p->pNext == phead)
{
printf("%d\t%p\t%p\t\n", p->data, p, p->pNext);
}
else
{
while (p->pNext != phead)
{
printf("%d\t%p\t%p\t\n", p->data, p, p->pNext);
p = p->pNext;
}
printf("%d\t%p\t%p\t\n", p->data, p, p->pNext);
}
}
}




node *Findfirst(node *phead, int data)
{
if (phead == NULL)
{
return NULL;

}
else
{
node *p = phead;
if (p->pNext == phead)
{
if (p->data == data)
{
return p;
}
else
{
return NULL;
}
}
else
{
while (p->pNext != phead)
{
if (p->data == data)
{
return p;
}
p = p->pNext;
}
if (p->data == data)
{
return p;
}
}
}
}

node *Delete(node *phead, int data)
{
if (phead == NULL)
{
return NULL;
}
else
{
node *p1 = phead,*p2=NULL;
while (p1->pNext != phead&&p1->data!=data)
{
p2 = p1;
p1 = p1->pNext;
}
if (p1 == phead)
{
node *ptemp = phead;
while (ptemp->pNext != phead)
{
ptemp = ptemp->pNext;
}
ptemp->pNext = phead->pNext;
free(phead);
phead = ptemp->pNext;
}
else
{
p2->pNext = p1->pNext;
free(p1);

}
}
return phead;
}

node *Insert(node *phead, int data)
{
node *pNew = add_node(data);
if (phead == NULL)
{
return NULL;
}
else
{
node *p1 = phead, *p2 = NULL;
if (p1->data < data)
{
node *p = phead;
while (p->pNext != phead)
{
p = p->pNext;
}
pNew->pNext = phead;
phead = pNew;
p->pNext = phead;

}
else
{
p1 = phead->pNext;
while (p1 != phead&&p1->data > data)
{
p2 = p1;
p1 = p1->pNext;
}
pNew->pNext = p2->pNext;
p2->pNext = pNew;
}
}
return phead;
}

int main(void)
{
node *phead = NULL;
for (int i = 1; i < 10; i++)
{
phead = add_head(phead, i);
}
showall(phead);
printf("\n");
//phead = Delete(phead, 1);
//phead = Insert(phead, 7);
showall(phead);
system("pause");
return 0;
}

三应用

一动态内存管理-链表实现

#include<stdio.h>
#include<stdlib.h>

//记录分配内存大小和地址
struct MEM{
void *p;
int size;
};
typedef struct MEM * ElementType;
typedef struct LinkNode{
ElementType pmem;
struct LinkNode *pNext;
}node,*PNODE;
struct LinkNode * phead =NULL;

//============================================================

PNODE AddBack(PNODE phead,struct MEM *pmem);//插入

PNODE Change(PNODE phead,void *pfind,ElementType pnewmem);

PNODE DeleteNode(PNODE phead,void *paddress);
void ShowAll(PNODE phead);
//============================================================
void *mymalloc(size_t size)//对malloc重新包装，实现对内存的监控
{
void *p;
p = malloc(size);
ElementType pmem = (ElementType)malloc(sizeof(struct MEM));
pmem->p = p;
pmem->size = size;
phead = AddBack(phead,pmem);
return p;
}
void myfree(void * p) //记录
{

phead = DeleteNode(phead,p);
free(p);
}
void *myrealloc(void *p,size_t size) //记录
{


void *pt=realloc(p,size);
ElementType pNew=(ElementType)malloc(sizeof(struct MEM));
pNew->p=pt;
pNew->size=size;
phead= Change(phead , p, pNew );
return pt;
}



//================================================================


PNODE AddBack(PNODE phead,ElementType pmem)
{
PNODE pNew;
pNew=(PNODE)malloc(sizeof(node));
pNew->pmem=pmem;
pNew->pNext=NULL;

if(phead==NULL)
{
phead=pNew;
}
else
{
PNODE ptemp=phead;
while(ptemp->pNext!=NULL)
{
ptemp=ptemp->pNext;
}
ptemp->pNext=pNew;
}
return phead;
}


PNODE DeleteNode(PNODE phead,void * paddress)
{
if(phead==NULL) return phead;

PNODE p1,p2=phead;
if(paddress==phead->pmem->p)
{
phead=p2->pNext;
free(p2);
}
else
{
while(p2!=NULL&&p2->pmem->p!=paddress)
{
p1=p2;
p2=p2->pNext;
}
p1->pNext=p2->pNext;
free(p2);
}
return phead;
}


PNODE Change(PNODE phead,void * pfind,ElementType pnewmem)
{
for(PNODE ptemp=phead;ptemp!=NULL; ptemp=ptemp->pNext)
{
if(ptemp->pmem->p==pfind)
{
ptemp->pmem = pnewmem;
return phead;
}
}

return phead;
}


void ShowAll(PNODE phead)
{


if(phead==NULL) return ;
PNODE ptemp=phead;
while(ptemp!=NULL)
{
printf("%p\t%d\t%p\t\n",ptemp->pmem,ptemp->pmem->size,ptemp->pmem->p);
ptemp=ptemp->pNext;
}
printf("\n");
}


//================================================================


#define malloc mymalloc //位置
#define free myfree
#define realloc myrealloc
int main (void)
{

void *p1=malloc(10) ;
void *p2=malloc(10) ;
void *p3=malloc(10) ;
void *p4=malloc(10) ;
void *p5=malloc(10) ;
ShowAll(phead);
free(p1);
ShowAll(phead);
realloc(p2,100);
ShowAll(phead);


return 0;
}

二一元多项式加法与乘法

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int count = 0;
struct node{
int Coefficient; //系数
int Exponent; //指数
struct node *pNext;
};

typedef struct node item;
void print(item *phead);
item *add(item *, item *);
item *addhead(item *phead,int Coefficient, int Exponent)
{
item *pNew;
pNew = (item *)malloc(sizeof(item));
pNew->Coefficient = Coefficient;
pNew->Exponent = Exponent;
pNew->pNext = NULL;

item *ptemp = phead;
if(phead == NULL)
{
phead = pNew;
}
else
if(ptemp->Exponent == Exponent)
{
ptemp->Coefficient += Coefficient;
free(pNew);
}
else
{
pNew->pNext = ptemp;
phead = pNew;
}

return phead;
}
item *mult( item *phead1, item *phead2)
{
item *multhead = NULL;

for(item *i=phead1 ; i!=NULL; i=i->pNext)
{
item *ahead = NULL;
item *ptemp = ahead;
for(item *j=phead2; j!=NULL; j=j->pNext)
{
item *pNew = (item *)malloc(sizeof(item));
pNew->Coefficient = i->Coefficient * j->Coefficient;
pNew->Exponent = i->Exponent + j->Exponent;
pNew->pNext = NULL;

if(ahead == NULL)
{
ahead = pNew;
ptemp = ahead;
}
else
{
ptemp->pNext = pNew;
ptemp = ptemp->pNext;
}

}
multhead = add(multhead, ahead);
}
return multhead;
}
item *add( item *phead1, item *phead2)
{
item *addphead = (item *)malloc(sizeof(item));
item *ptemp = addphead;
item *i = phead1, *j = phead2;

while(i != NULL && j != NULL)
{
item *pNew = (item *)malloc(sizeof(item));
if(i->Exponent < j->Exponent)
{
if(i->Coefficient!=0)
{
pNew->Coefficient = i->Coefficient;
pNew->Exponent=i->Exponent;
pNew->pNext=NULL;

ptemp->pNext = pNew;
ptemp = ptemp->pNext;
}
i = i->pNext;
}
else
if(i->Exponent > j->Exponent)
{
if(j->Coefficient!=0)
{
pNew->Coefficient = j->Coefficient;
pNew->Exponent=j->Exponent;
pNew->pNext=NULL;

ptemp->pNext = pNew;
ptemp = ptemp->pNext;
}
j = j->pNext;
}
else
if(i->Exponent == j->Exponent)
{
pNew->Coefficient = i->Coefficient + j->Coefficient;
if(pNew->Coefficient!=0)
{
pNew->Exponent = i->Exponent;
ptemp->pNext = pNew;
ptemp = ptemp->pNext;
}
i = i->pNext;
j = j->pNext;
}
}
if(i == NULL)
{
ptemp->pNext = j;
}
else
if(j == NULL)
{
ptemp->pNext = i;
}

return addphead->pNext;
}
void print(item *phead)
{
if(phead == NULL)
{
return ;
}
else
{
print(phead->pNext);
printf(count==0 ? "%d %d":" %d %d",phead->Coefficient , phead->Exponent);
count = 1;
}
}
int main (void)
{
item *phead1 = NULL, *phead2 = NULL, *addphead = NULL, *multphead = NULL;
int N, M;
int Coefficient, Exponent;

scanf("%d",&N);
for(int i = 1; i<=N; ++i)
{
scanf("%d%d",&Coefficient, &Exponent);
phead1=addhead(phead1,Coefficient, Exponent);
}
scanf("%d",&M);
for(int i = 1; i<=M; ++i)
{
scanf("%d%d",&Coefficient, &Exponent);
phead2=addhead(phead2,Coefficient, Exponent);
}

if(N*M==0)
{
printf("0 0\n");
}
else
{
multphead=mult(phead1,phead2);
if(multphead == NULL)
{
printf("0 0");
}
else
{
count = 0;
print(multphead);
}


printf("\n");
}

if(N==0&&M==0)
{
printf("0 0\n");
}
else
{
addphead=add(phead1,phead2);
if(addphead == NULL)
{
printf("0 0");
}
else
{
count = 0;
print(addphead);
}

printf("\n");
}

}

//以上为一己之见，还请大神指教    qq2110551525