50
社区成员
发帖
与我相关
我的任务
分享线性表的算法演示程序（链式+顺序）
1.线性表的链式存储结构的算法演示程序
//库函数引用
#include<stdio.h>
#include<stdlib.h>
#include<bits/stdc++.h>
//符号常量的定义
#define OK 1
#define ERROR 0
#define OVERFLOW -2
//数据类型的重命名、定义
typedef int Status;
typedef int ElemType;
//节点类型定义
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
//自定义函数的声明
void CreateList_L(LinkList &L, int n); //创建
Status ListInsert_L(LinkList &L,int i,ElemType e); //插入
Status ListDelete_L(LinkList &L,int i,ElemType &e);//删除
LNode *LocateELem_L (LinkList L, ElemType e); //按值查找
Status GetElem_L(LinkList L,int i,ElemType &e); //序号查找
int ListEmpty(LinkList L); //判空
void ListDisp_L(LinkList L); //遍历
int ListLength_L(LinkList L); //长度
Status DestroyList_L(LinkList &L); //销毁
//主函数
int main()
{
//局部变量定义
LinkList L;
int choice,z = 1;
int i;
int n;
ElemType e;
L = NULL;
//操作（死循环）
while(z)
{
//显示菜单
printf("------------线性表——链式存储结构------------\n");
printf("|**\t\t1.创建\t\t**\n");
printf("|**\t\t2.遍历\t\t**\n");
printf("|**\t\t3.插入\t\t**\n");
printf("|**\t\t4.删除\t\t**\n");
printf("|**\t\t5.按值查找\t**\n");
printf("|**\t\t6.按序号查找\t**\n");
printf("|**\t\t7.判空\t\t**\n");
printf("|**\t\t8.长度\t\t**\n");
printf("|**\t\t9.销毁\t\t**\n");
printf("|**\t\t0.退出\t\t**\n");
printf("请输入您要选择的菜单（0-9）： ");
scanf("%d",&choice);
switch(choice)
{
case 1: // 创建
//给已知：L（已知），n;
printf("请输入线性表长度: \n");
scanf("%d",&n);
CreateList_L(L,n);
printf("创建成功！\n\n");
break;
case 2: // 遍历
ListDisp_L(L);
printf("\n");
break;
case 3: //插入
//给已知，L已知,i,e;
printf("请输入插入位置： ");
scanf("%d",&i);
printf("请输入插入元素： ");
scanf("%d",&e);
if(OK == ListInsert_L(L,i,e))
{
printf("插入成功！\n");
}
else
{
printf("插入失败！\n");
}
break;
case 4: //删除
//给已知，L已知,i,e;
printf("请输入删除位置： ");
scanf("%d",&i);
if(OK == ListDelete_L(L,i,e))
{
printf("删除成功！\n");
}
else
{
printf("删除失败！\n");
}
break;
case 5: //按值查找
printf("请输入查找元素值：");
scanf("%d", &e);
if (LocateELem_L(L,e) != 0)
{
printf("该元素值地址为：%d\n",LocateELem_L(L,e));
}
else
{
printf("查找失败!\n");
}
break;
case 6: //按序号查找
printf("请输入您查找的序号： ");
scanf("%d",&i);
if(OK == GetElem_L(L,i,e))
{
printf("您查找的值为： %d\n",e);
}
else
{
printf("查找失败！\n");
}
break;
case 7: //判空
if(ListEmpty(L) == 0)
{
printf("不为空\n");
}
else
{
printf("为空");
}
break;
case 8: //长度
printf("该表长度为： %d\n",ListLength_L(L));
break;
case 9: //销毁
if(OK == DestroyList_L(L))
{
printf("销毁成功！\n");
}
else
{
printf("销毁失败！\n");
}
break;
case 0:
z = 0;
break;
default:
printf("输入错误！\n");
}
//让用户选择菜单
//根据用户的选择进行相应操作
}
return 0;
}
//带头节点的单链插入算法
Status ListInsert_L(LinkList &L,int i,ElemType e)
{ //在带头结点的单链表L中第i个位置插入值为e的新结点
LNode *p,*s;
p = L;
int j = 0;
while(p && j < i - 1)
{ //查找第i-1个结点,让p指向该结点
p = p -> next;
++j;
}
if(!p || j > i + 1)
return ERROR; //判断是否i＞n+1或者i＜1
s = new LNode; //生成新结点*s
s -> data = e;
s -> next = p -> next; //将结点*s的指针域指向结点ai
p -> next = s; //将结点*p的指针域指向结点*s
return OK;
} //ListInsert_L
//带头节点的单链表删除算法
Status ListDelete_L(LinkList &L,int i,ElemType &e)
{ //在带头结点的单链表L中，删除第i个元素
LNode *p,*q;
p = L;
int j = 0;
while(p && j < i - 1 )
{
p = p->next;
++j;
} //查找第i-1个结点，p指向该结点
if(!(p -> next) || j > i - 1)
return ERROR; //当i>n或i<1时，删除位置不合理
q = p -> next; //临时保存被删结点的地址以备释放
p -> next = q -> next; //改变删除结点前驱结点的指针域
e = q -> data; //保存删除结点的数据域
delete q; //释放删除结点的空间
return OK;
} //ListDelete_L
//带头节点的单链表按值查找算法
LNode *LocateELem_L (LinkList L, ElemType e)
{ //在带头结点的单链表L中查找值为e的元素
LNode *p = L->next;
p=L->next; //初始化，p指向首元结点
while(p && p->data != e) //顺序域向后扫描，直到p为空或p所指结点的数据域等于e
p=p->next; //p指向下一个结点
return p; //查找成功返回值为e的结点地址p，查找失败p为NULL
}
//带头节点的单链表按序号查找算法
Status GetElem_L(LinkList L,int i,ElemType &e)
{
LNode *p;
p = L->next;
int j = 1; //初始化
while(p && j < i)
{ //向后扫描，它没有直接前趋；直到p指向第i个元素或p为空
p = p->next; ++j;
}
if(!p || j > i)
return ERROR; //第i个元素不存在
e = p->data; //取第i个元素
return OK;
}
//带头节点的单链表创建算法
void CreateList_L(LinkList &L, int n)
{
//正位序输入n个元素的值，建立带表头结点的单链表L
LNode *r,*p;
int j;
printf("请输入数据元素：\n"); //给创建该长度的链表输入对应长度的数据元素
L = new LNode;
L->next = NULL; //先建立一个带头结点的空链表
r = L; //尾指针r指向头结点
for(j=0;j<n;++j)
{
p=new LNode; //生成新结点
scanf("%d",&p->data); //输入元素值赋值给结点*p的数据域
p->next=NULL;
r->next=p; //将新结点*p插入到尾结点*r之后
r=p; //r指向新的尾结点
}
} //CreateList_L
//带头节点的单链表的判空
int ListEmpty(LinkList L)
{
if (L->next!=NULL)
return 0;
else
return 1; //空表返回1
}
//带头节点的单链表的遍历
void ListDisp_L(LinkList L)
{
LinkList p=L->next;
while (p!=NULL)
{
printf("%5d",p->data); //有对齐，数据位数不够5位左不空格
p=p->next;
}
printf("\n");
}
//带头节点的单链表的长度
int ListLength_L(LinkList L)
{ //返回L中数据元素个数
LinkList p;
int i;
p=L->next; //p指向第一个结点
i=0;
while(p)
{ //遍历单链表,统计结点数
i++;
p=p->next;
}
return i;
}
//带头节点的单链表销毁
Status DestroyList_L(LinkList &L)
{
LinkList p;
while(L)
{
p=L;
L=L->next;
delete p; //消除p指的数据元素
}
return OK;
}
2.线性表的顺序存储结构的算法演示程序
//库函数的引用
#include<stdio.h>
#include<stdlib.h>
#include<bits/stdc++.h>
// 符号常量的定义
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
//数据类型的重命名、定义
typedef int Status;
typedef int ElemType;
typedef struct
{
ElemType *elem;
int length;
}SqList; //重命名
//自定义函数的声明
Status InitList( SqList &L ); //初始化
Status ListInsert(SqList &L,int i ,ElemType e);//插入算法
Status ListDelete(SqList &L,int i); //删除算法
Status GetElem(SqList L, int i, ElemType &e); //按序号查找
int LocateELem(SqList L,ElemType e); //按值查找
void DestroyList(SqList &L); //销毁线性表
void ClearList(SqList &L); //清空线性表
int IsEmpty(SqList L); //顺序表判空
int GetLength(SqList L); //顺序表长度
//主函数
int main()
{
SqList L;
int choice,z = 1;
int i;
ElemType e;
if(!InitList(L))
{
exit(0);
}
// 初始化
ListInsert( L, i, e); //调运初始化
//输出菜单
while(z)
{
printf("------------线性表- -顺序存储结构------------\n");
printf("|**\t\t1.插入\t\t\t**\n");
printf("|**\t\t2.删除\t\t\t**\n");
printf("|**\t\t3.按序号查找\t\t**\n");
printf("|**\t\t4.按值查找\t\t**\n");
printf("|**\t\t5.销毁顺序表\t\t**\n");
printf("|**\t\t6.清空顺序表\t\t**\n");
printf("|**\t\t7.顺序表判空\t\t**\n");
printf("|**\t\t8.顺序表长度\t\t**\n");
printf("|**\t\t9.输出线性表\t\t**\n");
printf("|**\t\t0.退出\t\t\t**\n");
printf("请输入您要选择的菜单（0-9）： ");
scanf("%d",&choice); //制作菜单
switch(choice)
{
case 1: // 插入数据元素
//给已知，L已知,i,e;
printf("请输入插入位置： ");
scanf("%d",&i);
printf("请输入插入元素： ");
scanf("%d",&e);
//调用
if(OK == ListInsert(L,i ,e))
{
printf("插入成功\n\n");
}
else
{
printf("插入失败\n\n");
}
break;
case 2: // 删除数据元素
printf("输入您想删除的位置\n");
scanf("%d",&i);
if(OK == ListDelete(L,i))
{
printf("删除成功\n\n");
}
else
{
printf("删除失败\n\n");
}
break;
case 3: // 按序号查找
printf("输入您想查找的元素序号\n");
scanf("%d",&i);
if(OK == GetElem(L,i,e))
{
printf("您查找的元素是：%d \n", e);
}
else
{
printf("您输入的序号有误\n");
}
break;
case 4: //按值查找
printf("输入您想查找的元素z值\n");
scanf("%d",&e);
if(LocateELem(L,e) != 0)
{
printf("您查找的元素值的位置是： %d\n",LocateELem(L,e));
}
else
{
printf("没有该元素值！\n");
}
break;
case 5: //销毁线性表
DestroyList(L);
printf("线性表删除成功！\n");
break;
case 6: //清空线性表
ClearList(L);
printf("线性表清空成功！ \n");
break;
case 7: //顺序表判空
if(IsEmpty(L) == 1)
{
printf("线性表为空！\n");
}
else
{
printf("线性表不为空! \n");
}
break;
case 8: //顺序表长度
printf("顺序表的长度为： %d\n",GetLength(L));
break;
case 9: //顺序表输出
for(int j = 0;j < L.length ;j ++)
{
printf("%d\n",L.elem[j]);
}
break;
case 0://退出程序
z = 0;
break;
default:
printf("输入错误!\n");
}
}
return 0;
}
//----------------------自定义函数----------------------//
//初始化
Status InitList( SqList &L ) //构造一个空的顺序表L
{
L.elem = new ElemType[MAXSIZE]; //为顺序表分配一个大小为MAXSIZE的数组空间
if(! L.elem) exit(OVERFLOW); //存储分配失败退出
L.length = 0; //空表长度为0
return OK;
}
//插入算法
Status ListInsert(SqList &L,int i ,ElemType e)
{//在顺序表L中第i个位置插入新的元素e,i值的合法范围是1≤i≤L.length+1
int j;
if(i<1 || i>L.length+1)
return ERROR; //i值不合法
if(L.length==MAXSIZE)
return ERROR; //当前存储空间已满
for(j=L.length-1;j >= i-1;j--)
L.elem[j+1]=L.elem[j]; //插入位置及之后的元素后移
L.elem[i-1]=e; //将新元素e放入第i个位置
L.length ++; //表长加1
return OK;
}
//删除算法
Status ListDelete(SqList &L,int i)
{//在顺序表L中删除第i个元素，i值的合法范围是1≤i≤L.length
int j;
if((i<1)||(i>L.length))
return ERROR; //i值不合法
for (j=i ; j<=L.length-1 ; j++)
L.elem[j-1]=L.elem[j]; //被删除元素之后的元素前移
--L.length; //表长减1
return OK;
}
//按序号查找
Status GetElem(SqList L, int i, ElemType &e)
{
if (i < 1 || i > L.length) //判断是否在链表长度内
return ERROR;
e = L.elem[i-1];
return OK;
}
//按值查找
int LocateELem(SqList L,ElemType e)
{//在顺序表L中查找值为e的数据元素，返回其序号
int i;
for (i = 0 ; i < L.length ; i++) //查找成功，返回序号i+1
if (L.elem[i] == e)
return i+1;
return 0; //查找失败，返回0
}
//销毁顺序表
void DestroyList(SqList &L)
{
if (L.elem) //判断线性表L已存在
delete[]L.elem; //销毁线性表L
}
//清空顺序表
void ClearList(SqList &L)
{
if (L.elem); //判断线性表L已存在
L.length=0; //将线性表L重置为空
}
//顺序表判空
int IsEmpty(SqList L)
{ if (L.length==0)
return 1; //如果顺序表L为空则返回1
else
return 0; //负责返回0
}
//顺序表长度
int GetLength(SqList L)
{
return (L.length); //返回顺序表L的长度值
}
...全文
请发表友善的回复…
发表回复
