typedef int Elemtype
const int ok=1
const int error=0
const int overflow=-2
const int TRUE=1
const int FALSE=0
typedef struct LNode{
Elemtype data
struct LNode *next
}LNode,*Linklist //定义单链表的结点类型
status initlist(Linklist &L) //初始化单链表
{
L=(Linklist) malloc(sizeof(LNode))
if(!L) exit(overflow)
L->next=NULL
//TODO1 生成单链表的头结点
return ok
}
status destroylist(Linklist &L)//销毁单链表
{ while(L)
{ Linklist p=L->next
free(L)
L=p
}
//TODO2
return ok
}
status listempty(Linklist &L) //判断单链表是否为空
{ if(L->next==NULL)
return TRUE
else return FALSE
//TODO3
return TRUE
}
int listlength(Linklist L) //求单链表的长度
{ Linklist p=L->next
int i=0
while(p)
return i
//TODO4
//p先指向第一个结点
//计数器清0
//当p所指向的结点存在，计数器加1，同时指针下移
//while语句结束时，p移出单链表
//返回单链表的长度；
}
void clearlist(Linklist &L) //清空单链表好胡旅
{while (L->next) {
Linklist p=L->next L->next=p->next
}
//TODO5
}
void printlist(Linklist L)//输出单链表里的每一个结点
{
Linklist
p=L->next
while(p)
{printf("%d",p->data)
p=p->next
}
//TODO6
//p指向头结点
//当p指向的结点存在，输出该结点，同时指针下移
}
status getelem(Linklist L,int i,Elemtype &e)//取表中第i个元素放到变量e里
{ Linklist p=L->nextint j=1
while(p&&j<i)
e=p->data
if(!p||j>i) return error
//TODO7
//p首先指向第一个元素
//while语句结束时，如果第i个结点存在，p指向它
//否则p指向表尾
//表中不存在第i个结友凳点或者表为空，返回出错信息
}
status listinsert(Linklist &L,int i,Elemtype e)//向表中第i个元素的前面插入元素e
{ Linklist p = L int j = 0
while (p &&j <i-1)
// 寻找第 (i-1) 个结点
if (!p || j >i-1)
return error
else
//TODO8
//p首先指向头结点
//如果第i个结点存在，while语句结束时，p指向第i-1个结点
//否则p指向表尾
//生成新的结点
//新的结点插入到p指向结点的后面（也就是插入到第i个结点的前面)
return ok
}
status listdelete(Linklist &L,int i,Elemtype &e)//删除表L中第i个元素,结果用e返回. *** 作成功返做御回ok,失败时返回error
{Linklist p = L int j = 0
while (p->next &&j <i-1)
// 寻找第 i-1 个结点，并令 p 指向它。
if (p->next&&j == i-1)
{Linklist q = p->next p->next = q->next // 删除并释放结点
e = q->data free(q)}
return ok
//TODO9
}
正好我大二的实验还在。。。但是还是想说一句，伸手党不适合做IT，建议楼主还是要自己多加练习，不会可以问，网上有很多乐意帮你解决问题的人。
#include "stdio.h"#include "string.h"
#include "ctype.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */
typedef int Status/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType/* ElemType类型根据实际情况而定，这里假设为int */
Status visit(ElemType c)
{
printf("%d ",c)
return OK
}
typedef struct Node
{
ElemType data
struct Node *next
}Node
typedef struct Node *LinkList /* 定义LinkList */
/* 初始化顺序线性表 */
Status InitList(LinkList *L)
{
*L=(LinkList)malloc(sizeof(Node)) /* 产生头结点,并使L指向此头结点 */
if(!(*L)) /* 存储分配失败 */
return ERROR
(*L)->next=NULL /* 指针域培此孙为空 */
return OK
}
/* 初始条件：顺序线性表L已存在。 *** 作结果：若L为空表，则返回TRUE，否则返回FALSE */
Status ListEmpty(LinkList L)
{
if(L->next)
return FALSE
else
return TRUE
}
/* 初始条件：顺序线性表L已存在。 *** 作结果：将L重置为空表 */
Status ClearList(LinkList *L)
{
LinkList p,q
p=(*L)->next /* p指向第一个结点 */
while(p) /* 没到表尾 */
{
q=p->next
free(p)
p=q
}
(*L)->next=NULL /* 头结点指针域为空 */
return OK
}
/* 初始条件：顺序线性表L已存在。 *** 作结果：返回L中数据元素个数 */
int ListLength(LinkList L)
{
int i=0
LinkList p=L->next /* p指向第一个结点 */
while(p)
{
i++
p=p->next
}
return i
}
/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* *** 作结果：用e返回L中第i个数据元素的值 */
Status GetElem(LinkList L,int i,ElemType *e)
{
int j
LinkList p /* 声明一结点p */
p = L->next /* 让p指向链表L的第一个结点 */
j = 1 /* j为计数器 */
while (p && j<i) /* p不为空或者计数器j还没有等于i时，循环继续 */
{
p = p->next /* 让p指向下一个结点 */
++j
}
if ( !p || j>i )
return ERROR /* 第i个元素不存在 */
*e = p->data /* 取第i个元素的数据 */
return OK
}
/* 初始条件：顺序线性表L已存在 */
/* *** 作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
int LocateElem(LinkList L,ElemType e)
{
int i=0
LinkList p=L->next
while(p)
{
i++
if(p->配链data==e) /* 找到这样的数据元素 */
return i
p=p->next
}
return 0
}
/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* *** 作结果：在L中第i个位置之前插入新的数据元素e，L的长扒轮度加1 */
Status ListInsert(LinkList *L,int i,ElemType e)
{
int j
LinkList p,s
p = *L
j = 1
while (p && j < i) /* 寻找第i个结点 */
{
p = p->next
++j
}
if (!p || j > i)
return ERROR /* 第i个元素不存在 */
s = (LinkList)malloc(sizeof(Node)) /* 生成新结点(C语言标准函数) */
s->data = e
s->next = p->next /* 将p的后继结点赋值给s的后继 */
p->next = s /* 将s赋值给p的后继 */
return OK
}
/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* *** 作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList *L,int i,ElemType *e)
{
int j
LinkList p,q
p = *L
j = 1
while (p->next && j < i) /* 遍历寻找第i个元素 */
{
p = p->next
++j
}
if (!(p->next) || j > i)
return ERROR /* 第i个元素不存在 */
q = p->next
p->next = q->next /* 将q的后继赋值给p的后继 */
*e = q->data /* 将q结点中的数据给e */
free(q) /* 让系统回收此结点，释放内存 */
return OK
}
/* 初始条件：顺序线性表L已存在 */
/* *** 作结果：依次对L的每个数据元素输出 */
Status ListTraverse(LinkList L)
{
LinkList p=L->next
while(p)
{
visit(p->data)
p=p->next
}
printf("\n")
return OK
}
/* 随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */
void CreateListHead(LinkList *L, int n)
{
LinkList p
int i
srand(time(0)) /* 初始化随机数种子 */
*L = (LinkList)malloc(sizeof(Node))
(*L)->next = NULL /* 先建立一个带头结点的单链表 */
for (i=0 i<n i++)
{
p = (LinkList)malloc(sizeof(Node)) /* 生成新结点 */
p->data = rand()%100+1 /* 随机生成100以内的数字 */
p->next = (*L)->next
(*L)->next = p /* 插入到表头 */
}
}
/* 随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法） */
void CreateListTail(LinkList *L, int n)
{
LinkList p,r
int i
srand(time(0)) /* 初始化随机数种子 */
*L = (LinkList)malloc(sizeof(Node)) /* L为整个线性表 */
r=*L /* r为指向尾部的结点 */
for (i=0 i<n i++)
{
p = (Node *)malloc(sizeof(Node)) /* 生成新结点 */
p->data = rand()%100+1 /* 随机生成100以内的数字 */
r->next=p /* 将表尾终端结点的指针指向新结点 */
r = p /* 将当前的新结点定义为表尾终端结点 */
}
r->next = NULL /* 表示当前链表结束 */
}
int main()
{
LinkList L
ElemType e
Status i
int j,k
i=InitList(&L)
printf("初始化L后：ListLength(L)=%d\n",ListLength(L))
for(j=1j<=5j++)
i=ListInsert(&L,1,j)
printf("在L的表头依次插入1～5后：L.data=")
ListTraverse(L)
printf("ListLength(L)=%d \n",ListLength(L))
i=ListEmpty(L)
printf("L是否空：i=%d(1:是 0:否)\n",i)
i=ClearList(&L)
printf("清空L后：ListLength(L)=%d\n",ListLength(L))
i=ListEmpty(L)
printf("L是否空：i=%d(1:是 0:否)\n",i)
for(j=1j<=10j++)
ListInsert(&L,j,j)
printf("在L的表尾依次插入1～10后：L.data=")
ListTraverse(L)
printf("ListLength(L)=%d \n",ListLength(L))
ListInsert(&L,1,0)
printf("在L的表头插入0后：L.data=")
ListTraverse(L)
printf("ListLength(L)=%d \n",ListLength(L))
GetElem(L,5,&e)
printf("第5个元素的值为：%d\n",e)
for(j=3j<=4j++)
{
k=LocateElem(L,j)
if(k)
printf("第%d个元素的值为%d\n",k,j)
else
printf("没有值为%d的元素\n",j)
}
k=ListLength(L) /* k为表长 */
for(j=k+1j>=kj--)
{
i=ListDelete(&L,j,&e) /* 删除第j个数据 */
if(i==ERROR)
printf("删除第%d个数据失败\n",j)
else
printf("删除第%d个的元素值为：%d\n",j,e)
}
printf("依次输出L的元素：")
ListTraverse(L)
j=5
ListDelete(&L,j,&e) /* 删除第5个数据 */
printf("删除第%d个的元素值为：%d\n",j,e)
printf("依次输出L的元素：")
ListTraverse(L)
i=ClearList(&L)
printf("\n清空L后：ListLength(L)=%d\n",ListLength(L))
CreateListHead(&L,20)
printf("整体创建L的元素(头插法)：")
ListTraverse(L)
i=ClearList(&L)
printf("\n删除L后：ListLength(L)=%d\n",ListLength(L))
CreateListTail(&L,20)
printf("整体创建L的元素(尾插法)：")
ListTraverse(L)
return 0
}
-----------线性表的单链表存储结构-------------typedef struct Node{
ElemType data
struct Node *next
} *LNode, *LinkList
//----------线性表的单链表基本 *** 作------------
LinkList InitList(void)//构造一个空的线性表
void DestroyList(LinkList *L)//初始条件：线性表L已存在。 *** 作结果：销毁线性表L。
LinkList MakeEmpty(LinkList L)//初始条件：线性表L已存搜漏宴在。 *** 作结果：将线性表L重置为空表。
int IsEmpty(LinkList L)//初始条件：线性表L已存在。 *** 作结果：判断线性表是否为空表。
int ListLength(LinkList L)//初始条件：线性表L已存在。 *** 作结果：返回线性表L结点的个数。
LNode IsLast(LinkList L)//初始条件：线性表L已存在。 *** 作结果：返回线性表L的最后一个结点（尾结点）。
LNode NewLNode(ElemType X)//构造一个数据域为X的新结点
LNode FindPrefious(ElemType X, LinkList L)//初始条件：线性表L已存在。 *** 作结果：在线性表L中寻找值为X的结点，若找到则返回该结点的前驱，否则返回NULL。
void ListDelete(LNode Pre)//初始条件：线性表L中结点P已找到。 *** 作结果：删除该结点。
void ListInsert(LNode Pre, LNode S)//初始条件：线性表L中结点P已找到，新结点S已构造。 *** 作结果：在该结点之前插入新结点X。
----------线性表的单链表基本 *** 作的算法实现------------
//我给链表设置了一个头结点,虽然它的数据域毫无意义,但它作为一个指针却意义非凡!
//它的作用我们在下面的例程中可以领教
LinkList InitList(void) //构造一个空的线性表
{
LNode Head
Head = (LNode)malloc(sizeof(struct Node))//为链表的头结点分配空间
if(!Head)
{
printf("Out of space!")
return NULL
}
Head->next = NULL
return Head//返回头结点
}
void DestroyList(LinkList *L)//初始条件：线性表L已存在。 *** 作结果：销毁线性表L。
{
LNode Head, P
if(*L)//若线性表L已存在
{
Head = *L
P = Head->next
while(!P) //把链表中除头结点外的所有结点释放
{
free(Head)
Head = P
P = Head->next
}
free(Head)//释放头结点
}
}
LinkList MakeEmpty(LinkList L)//初始条件：线性表L已存在。 *** 作结果：将线性表L重置为空表。
{
LNode Head, P
Head = *L
P = Head->next
while(!P)//把链表中除头结点外的所有结世银点释放
{
free(Head)
Head = P
P = Head->next
}
return (Head)//返回头结点
}
int IsEmpty(LinkList L)//初始条件：线性表L已存在。 *** 作结果：判断线性表是否为空表。
{
return L->next == NULL
}
int ListLength(LinkList L)//初始条件：线性表L已存在。 *** 作结果：返回线性表L结点的个数。
{
LNode P = L->next
int num = 0
while(P) //累积线性表L结点的个数
{
num++
P = P->next
}
return num//返回线性表L结点的个数
}
//初始条件：线性搜帆表L已存在。 *** 作结果：返回线性表L的最后一个结点（尾结点）。
LNode IsLast(LinkList L)
{
LNode P = L->next
if(P)
{
while(P->next) //遍历线性表L
P = P->next
}
return P//返回线性表L的最后一个结点，若为空表则返回NULL
}
LNode NewLNode(ElemType X)//构造一个数据域为X的新结点
{
LNode S
S = (LNode)malloc(sizeof(struct Node))//为新结点分配空间
if(!S)
{
printf("Out of space!")
return NULL
}
S->data = X
S->next = NULL
return S//返回新结点
}
//线性表L已存在。 *** 作结果：在线性表L中寻找值为X的结点，若找到则返回该结点的前驱，否则返回NULL。
LNode FindPrefious(ElemType X, LinkList L)
{
LNode P = L
while(P->next &&P->next->data != X)//遍历链表寻找值为X的结点
P = P->next
if(!P->next) //如果找不到值为X的结点,返回NULL
return NULL
else //若找到则返回该结点的前驱P
return P
}
void ListDelete(LNode Pre)//初始条件：线性表L中结点P已找到。 *** 作结果：删除该结点。
{
LNode P = Pre->next
Pre->next = P->next
free(P)
}
//初始条件：线性表L中结点P已找到，新结点S已构造。。 *** 作结果：在该结点之前插入新结点X。
void ListInsert(LNode Pre, LNode S)
{
S->next = Pre->next
Pre->next = S
}
如果还没解决你的问题，可以加我百度HI账号。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）