c语言顺序表销毁函数,c语言退出函数的语句
数据结构 c语言版 ——顺序表的查找、插入与删除
#includestdio.h
创新互联公司是一家专业从事成都网站制作、网站设计、网页设计的品牌网络公司。如今是成都地区具影响力的网站设计公司,作为专业的成都网站建设公司,创新互联公司依托强大的技术实力、以及多年的网站运营经验,为您提供专业的成都网站建设、营销型网站建设及网站设计开发服务！
#includestdlib.h
#define N 10 //顺序表的最大容量
int length=0; //顺序表的当前元素个数
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define LIST_INIT_SIZE 100//线性表存储的空间初始化分配量
#define LISTINCREAMENT 10 //线性表存储空间的分配增量
typedef struct LNode//线性单链表存储结构
{
int data;
struct LNode *next;
}LNode,*LinkList;
int CreatList_L(LinkListL)//创建一个线性链表
{
L=(LinkList)malloc(sizeof(LNode));//分配一个空间给链表，作为头结点
if(!L) exit(OVERFLOW);
L-next=NULL;
return OK;
}
int DestroyList_L(LinkList L)//销毁链表
{
if(L) free(L);
return OK;
}
int ListInsert_L(LinkListL,int i,int e)//再练表的第i个元素前插入一个元素e
{
LinkList p=L;//p指针定位于i-1
LNode *s;
int j=0;
while(pji-1) {p=p-next;j++;}//定位
if(!p||ji-1) return ERROR;//如果i1或大于链表元素个数+1
s=(LNode*)malloc(sizeof(LNode));
if(!s) exit(OVERFLOW);
s-data=e; //完成插入操作
s-next=p-next;
p-next=s;
return OK;
}
int ListDelet_L(LinkListL,int i,inte)//删除链表L中的第i个元素，并返回给e;
{
LinkList p=L;
LNode* q;
int j=0;
while(!pji-1) {p=p-next;j++;}//p指针定位于i-1；
if(!p-next||ji-1) return ERROR;
e=p-next-data; //完成删除操作
q=p-next;
p-next=p-next-next;
free(q);
return OK;
}
int ListTraverse_L(LinkList L,int n)//链表的遍历
{
int i=0;
if(!L)return ERROR;
L=L-next;
while(L)
{
if(L-data==n)return i;
L=L-next;
i++;
}
return FALSE;
}
int InverseSingleList_L(LinkList L)
{
if(!L-next||!L-next-next)//如果链表少于2个Node那么链表不需要改变顺序
return OK;
LNode *p,*q;
p=L-next; //第一次因为p是最后一个连接所以把p-next设为空
q=p-next;
p-next=NULL;
p=q;
while(p)
{
q=p-next; //用q去保留p后面一个Node;
p-next=L-next;
L-next=p;
p=q;
}
return OK;
}
int main()
{
int List[N];
LinkList L;
int ch,exit='N';
do
{
system("CLS");
printf("\t\t********************************************\n");
printf("\t\t* 1.创建一个顺序表 .........(1) *\n");
printf("\t\t* 2.在顺序表中查找元表.........(2) *\n");
printf("\t\t* 3.在顺序表中插入元表.........(3) *\n");
printf("\t\t* 4.在顺序表中删除元表.........(4) *\n");
printf("\t\t* 5.退出 .........(5) *\n");
printf("\t\t********************************************\n");
printf("\n请选择操作代码：");
ch=getchar();
switch(ch)
{
case '1':
printf("\n请输入十个元素");
CreatList_L(L);
for(length=0;lengthN;length++)
{
scanf("%d",List[length]);
getchar();
ListInsert_L(L,length+1,List[length]);
}
printf("\n创建成功！");
getchar();
break;
case '2':
scanf("%d",List[0]);
if(ListTraverse_L(L,List[0]))printf("该元素存在该年表的第%d个位置",ListTraverse_L(L,List[0]));
else printf("不存在该元素");
getchar();
break;
case '3':
scanf("%d%d",length,List[0]);
ListInsert_L(L,length,List[0]);
system("pause");
break;
case '4':
scanf("%d",length);
ListDelet_L(L,length,List[0]);
system("pause");
break;
case '5':
printf("\n您是否真的要退出程序(Y/N):");
getchar();
exit=getchar();
break;
default:
getchar();
printf("\n无效输入，请重新选择...:");
getchar();
break;
}
}while(exit!='y'exit!='Y');
}
C语言中 销毁一个动态链表的函数 该怎么写啊？？
到底是问链表还是数列呀？
可以这样写，传入的是头指针
void DeleteList(LIST* head)
{
LIST* tmp;
tmp = head;
while(tmp!=NULL)
{
head = tmp-next;
free(tmp);
tmp = head;
}
}
递归算菲数列的
long fi(int n)
{
if (n==1||n==2) return 1;
return fi(n-1)+fi(n-2);
}
其实用递归算菲波拉契数列很慢的，很快就栈溢出了。
数据结构实验（C语言）： 顺序表实验
//线性表函数操作
#include stdio.h
#include string.h
#define MaxSize 30
#define Error 0
#define True 1
typedef char ElemType;
typedef struct
{
ElemType elem[MaxSize];
int length;
}SqList; /*顺序表类型定义*/
void InitList(SqList * L) /*初始化顺序表L*/
{
L = (SqList *)malloc(sizeof(SqList));
L - length = 0;
}
void DestroyList( SqList *L ) /*释放顺序表L*/
{
free(L);
}
int ListEmpty( SqList *L ) /*判断顺序表L是否为空表*/
{
return( L - length == 0);
}
int ListLength( SqList *L ) /*返回顺序表L的元素个数*/
{
return( L - length);
}
void DispList( SqList *L ) /*输出顺序表L*/
{
int i;
if( ListEmpty(L))
return;
for( i = 0; i L - length; i++ )
printf("%c", L - elem[i]);
printf("\n");
}
int GetElem( SqList *L, int i, ElemType e) /*获取顺序表中的第i个元素*/
{
if( i 1 || i L - elem[i])
return Error;
e = L - elem[i - 1];
return True;
}
int LocateElem( SqList *L, ElemType e) /*在顺序表中查找元素e*/
{
int i = 0;
while( i L - length L - elem[i] != e)
i++;
if(i = L - length)
return Error;
else
return i+1;
}
int ListInsert( SqList * L, int i, ElemType e) /*在顺序表L中第i个位置插入元素e*/
{
int j;
if( i 1 || i L - length + 1)
return 0;
i--; /*将顺序表位序转化为elem下标*/
for( j = L - length; j i; j--) /*将elem[i]及后面元素后移一个位置*/
L - elem[j] = L - elem[j - 1];
L - elem[i] = e;
L - length++; /*顺序表长度增1*/
return True;
}
int ListDelete( SqList * L, int i, ElemType e) /*顺序表L中删除第i个元素*/
{
int j;
if( i 1 || i L - length)
return Error;
i--; /*将顺序表位序转化为elem下标*/
e = L - elem[i];
for(j = i; j L - length - i; j++)
L - elem[j] = L - elem[j + 1];
L - length--; /*顺序表长度减1*/
return True;
}
void main()
{
SqList *L;
ElemType e;
printf("(1)初始化顺序表L\n");
InitList(L);
printf("(2)依次采用尾插法插入a,b,c,d,e元素\n");
ListInsert(L, 1, 'a');
ListInsert(L, 2, 'b');
ListInsert(L, 3, 'c');
ListInsert(L, 4, 'd');
ListInsert(L, 5, 'e');
printf("(3)输出顺序表L:");
DispList(L);
printf("(4)顺序表L长度 = %d\n", ListLength(L));
printf("(5)顺序表L为%s\n", (ListEmpty(L) ?"空" :"非空"));
GetElem(L, 3, e);
printf("(6)顺序表L的第3个元素 = %c\n", e);
printf("(7)元素a的位置 = %d\n", LocateElem(L,'a'));
printf("(8)在第4个元素位置上插入f元素\n");
ListInsert(L, 4, 'f');
printf("(9)输出新的顺序表L:");
DispList(L);
printf("(10)删除L的第3个元素\n");
ListDelete(L, 3, e);
printf("(11)输出新的顺序表L:");
DispList(L);
printf("(12)释放顺序表L\n");
DestroyList(L);
}
C语言线性顺序表的插入和删除
#include"stdio.h"
#include"malloc.h"
#include"iostream.h"
typedef int status;
typedef int elementype;
#define INITSIZE 100
#define INCREMENT 2
struct sqlist
{
elementype *elem;
int length;
int listsize;
};
//建立链表，并排列数据
status listinit(sqlist l)
{
int i=0,x,j,t;
l.elem=(elementype *)malloc(INITSIZE*sizeof(elementype));
if(!l.elem)
{
cout"建表失败"endl;
return 0;
}
l.length=0;
l.listsize=INITSIZE;
while(1)
{
cout"请输入数据(输入0时结束):";
cinx;
if(x==0) break;
l.elem[i]=x;
++l.length;
i++;
}
for(i=0;il.length-1;i++)
for(j=0;jl.length-i-1;j++)
if(l.elem[j]l.elem[j+1])
{
t=l.elem[j+1];
l.elem[j+1]=l.elem[j];
l.elem[j]=t;
}
cout"排序成功"endl;
return 1;
}
//插入数据
status listinsert(sqlist l,int i,elementype e)
{
elementype *p,*q,*newbase;
if(i1||il.length)
{
cout"i输入错误"endl;
return 0;
}
if(l.length=l.listsize)
{
newbase=(elementype*)realloc(l.elem,(l.listsize+INCREMENT)*sizeof(elementype));
if(!newbase)
{
cout"申请空间失败"endl;
return 0;
}
l.elem=newbase;
l.listsize=l.listsize+INCREMENT;
}
q=(l.elem[i-1]);
for(p=(l.elem[l.length-1]);p=q;--p)
{
*(p+1)=*p;
}
*q=e;
++l.length;
cout"插入成功";
return 1;
}
//删除数据
status listdelete(sqlist l,int i,elementype e)
{
elementype *p,*q;
if(i1||il.length)
{
cout"i输入错误"endl;
return 0;
}
p=(l.elem[i-1]);
e=*p;
q=l.elem+l.length-1;
for(++p;p=q;++p)
{
*(p-1)=*p;
}
--l.length;
cout"删除成功"endl;
free(e);
return 1;
}
//删除重复的数据
status listdeleterepeat(sqlist l)
{
int i,j;
elementype *p,*q,e;
for(i=0;il.length-1;i++)
for(j=i+1;jl.length-1;j++)
if(l.elem[i]==l.elem[j])
{
p=(l.elem[j]);
e=*p;
q=l.elem+l.length-1;
for(++p;p=q;++p)
{
*(p-1)=*p;
}
--l.length;
free(e);
j--;
}
return 1;
}
//输出顺序表数据
status displaylist(sqlist l)
{
int i;
cout"顺序表的数据为:"endl;
for(i=0;il.length;i++)
{
coutl.elem[i]" ";
}
coutendl;
return 1;
}
//查找数据
status locatelem(sqlist l,int x)
{
elementype *p;
int i=1;
p=l.elem;
while(il.length(*p++)!=x)
i++;
coutiendl;
return 1;
}
//清空列表
void listclear(sqlist l)
{
l.length=0;
}
//销毁顺序表
void listdestroy(sqlist l)
{
if(l.elem)
free(l.elem);
}
//求顺序表长度
status listlength(sqlist l)
{
cout"顺序表的长度为:"l.lengthendl;
return 1;
}
int main()
{
sqlist l;
int a,i,x;
elementype e;
cout"*************************************************"endl;
cout"* 顺序表的表示和实现 *"endl;
cout"*************************************************"endl;
do{
cout"*************************************************"endl;
cout"* 菜单 *"endl;
cout"* 1.建立顺序表 *"endl;
cout"* 2.插入数据 *"endl;
cout"* 3.删除数据 *"endl;
cout"* 4.删除重复数据 *"endl;
cout"* 5.清空数据 *"endl;
cout"* 6.查找数据 *"endl;
cout"* 7.顺序表的长度 *"endl;
cout"* 8.显示顺序表 *"endl;
cout"* 0.退出顺序表 *"endl;
cout"*************************************************"endl;
cout"输入你的选择:";
cina;
switch(a)
{
case 1: listinit(l);
displaylist(l);
break;
case 2: cout"请输入要插入数据的位置:";
cini;
cout"请输入要插入的数据元素:";
cine;
listinsert(l,i,e);
displaylist(l);
break;
case 3: cout"请输入要删除的数据的位置:";
cini;
listdelete(l,i,e);
displaylist(l);
break;
case 4: cout"删除前的数据为:";
displaylist(l);
listdeleterepeat(l);
cout"删除后的数据为:";
displaylist(l);
break;
case 5: cout"清空前为:";
displaylist(l);
cout"清空后为:";
listclear(l);
displaylist(l);
break;
case 6: cout"输入你要查找的数据:";
cinx;
cout"你要查找的数据的位置为:";
locatelem(l,x);
displaylist(l);
break;
case 7: cout"顺序表的长度为:";
listlength(l);
break;
case 8: displaylist(l);
break;
default: break;
}
}while(a!=0);
return 1;
}
c语言销毁栈的函数。大家看看写的对不？
这两个函数一个是销毁栈DestroyStack，一个是清空栈ClearStack
销毁是把整个栈都释放掉，清空只是把栈里元素清除。
因为你的栈元素是int型基本变量，所以栈元素内容是直接存放在栈空间的，并没有另外申请内存保存栈元素，所以在从栈里移除栈元素时，不需要调用free函数。
实际上你的DestroyStack可以很直接的如下：
int DestroyStack(stack s)
{
free(s.base); //释放栈空间，这里假设s.base是个指针而不是数组
//如果s结构也是动态申请的，也需要执行free(s);
}
至于ClearStack，书上写的是没问题的，清空栈，不是要释放栈空间，而是把栈里的元素都清除，最直接的做法就是把栈顶指针指向栈底指针，栈顶和栈底指针相同时，就表示栈内无元素，栈空间还是保留，下次可以继续把栈元素压栈和弹栈。
数据结构（C语言） 销毁顺序表的函数体是什么 急！！！！！
void destroyLink(Node *head)
{
if(!head)
return;
Node* pTemp=head-pNext;
delete head;
destroyLink(pTemp);
}
当前名称：c语言顺序表销毁函数,c语言退出函数的语句
地址分享：http://6mz.cn/article/dsgejsg.html