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);

}