销毁线性表算法

⑴ 如何算是销毁一个线性表

不可以直接释放头结点的，必须所有的结点全部释放掉，最后释放头结点
如果直接将头结点置空，会导致其它结点元素所占空间不被有效释放，产生内存泄露

一个比较规正的清空线性表的代码如下：
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); //释放头结点
}
}

⑵ 顺序表、链表清空和销毁

我正好在学数据结构，以下是我的理解，自以为还比较靠谱。你参考着看吧。
ClearList只是把线性表中原来存储元素的空间中存的那些元素都清除了，类似于把原线性表改成一个空的线性表，但这个线性表是确实存在的。
而Destroy是把整个线性表占的空间都释放了，这个线性表结构都不存在了，下次想做一个线性表只能重新初始化。
下面是我在老师给的课件找到的粗略算法：
顺序表的：
销毁线性表L
void DestroyList(SqList*L)
{
if (L->elem) free(L->elem); //释放线性表占据的所有存储空间
}
清空线性表L
void ClearList(SqList*L)
{
L->length=0; //将线性表的长度置为0
}
链表的：
销毁链表L
void DestoryList(LinkList *L)
{
NODE *p;
while (L->head){ //依次删除链表中的所有结点
p=L->head; L->head=L->head->next;
free(p);
}
}
清空链表L
void ClearList(LinkList *L)
{
NODE *p;
while (L->head->next){
p=L->head->next; //p指向链表中头结点后面的第一个结点
L->head->next=p->next; //删除p结点
free(p); //释放p结点占据的存储空间
}
}
具体的在C环境编程实现的话还要加工下的。
希望能给你点启发！

⑶ 设计算法删除线性表中的多余元素

Node*p=head;
while(p->next!=NULL){
inta=p->data;
intb=p->next.data;
if(a==b){
p->next=p->next->next;
}

p=p->next;

是不是就行了。。

⑷ 线性表的基本操作c语言实现

代码如下：

头文件：

2_1.h

#ifndef _2_1_H

#define _2_1_H

typedef void SeqList;

typedef void SeqListNode;

//创建线性表

SeqList * SeqList_Create(int capacity);

//销毁线性表

void SeqList_DesTroy(SeqList * list);

void SeqList_Clear(SeqList* list);

int SeqList_Length(SeqList* list);

int SeqList_Capacity(SeqList* list);

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);

SeqListNode* SeqList_Get(SeqList* list, int pos);

SeqListNode* SeqList_Delete(SeqList* list, int pos);

#endif

源文件：

// 顺序线性表.cpp : 定义控制台应用程序的入口点。

//

#include "stdafx.h"

#include <malloc.h>

#include <stdlib.h>

#include "2_1.h"

typedef unsigned int TSeqListNode;

typedef struct {

int len; //长度

int capacity;//总长度

TSeqListNode * node;//每个节点的指针

} TSeqList;

int main()

{

SeqList* list = SeqList_Create(5);//创建线性表

int i = 6;//赋值6个变量，已超过线性表最大值 5

int j = 1;

int k = 2;

int x = 3;

int y = 4;

int z = 5;

int index = 0;

SeqList_Insert(list, &i, 7); //将这6个变量插入线性表中

SeqList_Insert(list, &j, 0);

SeqList_Insert(list, &k, 0);

SeqList_Insert(list, &x, 0);

SeqList_Insert(list, &y, 0);

SeqList_Insert(list, &z, 0);

//遍历

for(index=0; index<SeqList_Length(list); index++)

{

int* p = (int*)SeqList_Get(list, index);

printf("%d ", *p);

}

printf(" ");

//删除操作

while( SeqList_Length(list) > 0 )

{

int* p = (int*)SeqList_Delete(list, 0);

printf("删除了： %d ", *p);

}

SeqList_Clear(list);

SeqList_DesTroy(list);

system("pause");

return 0;

}

//创建线性表

SeqList * SeqList_Create(int capacity)

{

TSeqList* ret = NULL ;

if(capacity >= 0)

{

ret = (TSeqList*)malloc(sizeof(TSeqList) + sizeof(TSeqListNode)*capacity); //为线性表分配空间，包含结 //构体和节点的总大小

}

if(NULL != ret)

{

ret->len = 0;

ret->capacity = capacity;

ret->node = (TSeqListNode*)(ret + 1);//将节点指向上述分配到的空间的后部分

}

return ret;

}

//销毁

void SeqList_DesTroy(SeqList * list)

{

free(list);

}

//清空

void SeqList_Clear(SeqList* list)

{

TSeqList * ret = (TSeqList*)list;

if(NULL != ret)

{

ret->len = 0;

}

}

//获得线性表的长度

int SeqList_Length(SeqList* list)

{

TSeqList * ret = (TSeqList*)list;

int len = -1;

if(NULL != ret)

{

len = ret->len;

}

return len;

}

//线性表的总长度

int SeqList_Capacity(SeqList* list)

{

TSeqList * ret = (TSeqList*)list;

int capacity = -1;

if(NULL != ret)

{

ret->capacity = capacity;

}

return capacity;

}

//插入

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)

{

TSeqList * sList = (TSeqList*)list;

int i,ret = -1;

if((sList != NULL) &&(pos >= 0) && sList->capacity >= sList->len+1)

{

if(pos >= sList->len)

{

pos = sList->len;

}

for(i = sList->len; i > pos; i--)

{

sList->node[i] = sList->node[i-1];

}

sList->node[i] = (TSeqListNode)node;

++sList->len;

ret = 1;

}

return ret;

}

//获得指定位置的节点

SeqListNode* SeqList_Get(SeqList* list, int pos)

{

TSeqList * sList = (TSeqList*)list;

TSeqListNode* node = NULL;

if(NULL != sList && pos>=0 && pos < sList->len)

{

node = (TSeqListNode*)sList->node[pos];

}

return node;

}

//删除

SeqListNode* SeqList_Delete(SeqList* list, int pos)

{

TSeqList * sList = (TSeqList*)list;

SeqListNode * node = SeqList_Get( list, pos);

int i;

if(sList != NULL && pos >= 0 && pos< sList->len)

{

for( i=pos+1; i<sList->len; i++)

{

sList->node[i-1] = sList->node[i];

}

sList->len--;

}

return node;

}

演示：

资料拓展：

线性表是最基本、最简单、也是最常用的一种数据结构。

线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储），但是把最后一个数据元素的尾指针指向了首位结点）。

我们说“线性”和“非线性”，只在逻辑层次上讨论，而不考虑存储层次，所以双向链表和循环链表依旧是线性表。

在数据结构逻辑层次上细分，线性表可分为一般线性表和受限线性表。一般线性表也就是我们通常所说的“线性表”，可以自由的删除或添加结点。受限线性表主要包括栈和队列，受限表示对结点的操作受限制。

线性表的逻辑结构简单，便于实现和操作。因此，线性表这种数据结构在实际应用中是广泛采用的一种数据结构。

⑸ 1：线性表及其应用 （1）： 顺序表操作验证（包括建立、查找、插入、删除、销毁等操作） （2）：单链表操

随便找本算法书都有啊

⑹ 线性表删除元素的算法

如果是数组，那么把第i个之前的元素都往前移一位，需要O(n)的时间
如果是链表，那么把第i+1个元素直接接到第i-1个元素后面来，需要O(1)的时间。

⑺ 怎样用C语言摧毁线性表

线性表实际上就是一个数组，清空操作就意味着清除数组当前保存的所有元素，表的长度归0，以后的数组插入操作要从0下标元素开始，所以也就不需要再费时去一个一个清除元素值，或者重新分配数组空间了，直接将长度归0就可以了，之后在插入元素时（清空后的第一个操作只能是插入元素，不能取元素或者删除元素）通过表长度判断应该插入到何处（清空后的第一次插入只能放在0下标位置）。

所以，书上的说法是正确的，照书上的来就可以了，当然如果定义了一个指针，那么首先要用malloc()等函数分配空间，然后再L->Length=0;

⑻ 线性表销毁的详细介绍

要销毁的话从头结点开始依次free 但注意先得到下一个节点再free

⑼ 一个线性表采用顺序表表示，设计一个算法，删除其中所有值等于X的元素完整的C语言程序

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

#defineElemTypeint
#defineStatusint
#defineOVERFLOW-1
#defineERROR0
#defineOK1

/*线性表的动态分配顺序存储结构*/
#defineLIST_INIT_SIZE10/*线性表存储空间的初始分配量*/
#defineLIST_INCREMENT2/*线性表存储空间的分配增量*/
typedefstruct{
	ElemType*elem;/*存储空间基址*/
	intlength;/*当前长度*/
	intlistsize;/*当前分配的存储容量(以sizeof(ElemType)为单位)*/
}SqList;

/*操作结果：构造一个空的顺序线性表L*/
voidInitList(SqList*L){
	L->elem=malloc(LIST_INIT_SIZE*sizeof(ElemType));
	if(!L->elem)
		exit(OVERFLOW);/*存储分配失败*/
	L->length=0;/*空表长度为0*/
	L->listsize=LIST_INIT_SIZE;/*初始存储容量*/
}

/*初始条件：顺序线性表L已存在。操作结果：销毁顺序线性表L*/
voidDestroyList(SqList*L){
	free(L->elem);
	L->elem=NULL;
	L->length=0;
	L->listsize=0;
}

/*初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1*/
/*操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1*/
StatusListInsert(SqList*L,inti,ElemTypee){
	ElemType*newbase,*q,*p;
	if(i<1||i>L->length+1)/*i值不合法*/
		returnERROR;
	if(L->length>=L->listsize){/*当前存储空间已满,增加分配*/
		newbase=realloc(L->elem,(L->listsize+LIST_INCREMENT)*sizeof(ElemType));
	if(!newbase)
			exit(OVERFLOW);/*存储分配失败*/
		L->elem=newbase;/*新基址*/
		L->listsize+=LIST_INCREMENT;/*增加存储容量*/
	}
	q=L->elem+i-1;/*q为插入位置*/
	for(p=L->elem+L->length-1;p>=q;--p)/*插入位置及之后的元素右移*/
		*(p+1)=*p;
	*q=e;/*插入e*/
	++L->length;/*表长增1*/
	returnOK;
}

/*初始条件：顺序线性表L已存在，1≤i≤ListLength(L)*/
/*操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1*/
StatusListDelete(SqList*L,inti,ElemType*e){
	ElemType*p,*q;
	if(i<1||i>L->length)/*i值不合法*/
		returnERROR;
	p=L->elem+i-1;/*p为被删除元素的位置*/
	*e=*p;/*被删除元素的值赋给e*/
	q=L->elem+L->length-1;/*表尾元素的位置*/
	for(++p;p<=q;++p)/*被删除元素之后的元素左移*/
		*(p-1)=*p;
	L->length--;/*表长减1*/
	returnOK;
}

/*初始条件：顺序线性表L已存在，1≤i≤ListLength(L)*/
/*操作结果：打印顺序线性表所有元素*/
voidOutputList(SqList*L){
	ElemType*p;
	inti;
	p=L->elem;/*p的初值为第1个元素的存储位置*/
	for(i=1;i<=L->length;i++,p++)
		printf("%d	",*p);
	putchar('
');
}

intmain(){
	SqListL;/*定义顺序表*/
	ElemType*p,e;
	inti;
	
	ElemTypeX=5;/*程序欲删除元素值为X的元素*/
	
	InitList(&L);/*初始化顺序表*/
	/*插入若干元素*/
	ListInsert(&L,1,1);
	ListInsert(&L,1,2);
	ListInsert(&L,3,5);
	ListInsert(&L,4,3);
	ListInsert(&L,5,5);
	ListInsert(&L,6,4);
	
	printf("初始顺序线性表内容为：
");
	OutputList(&L);
	putchar('
');
	
	/*删除元素值为x的元素*/
	p=L.elem;/*p的初值为第1个元素的存储位置*/
	for(i=1;i<=L.length;i++,p++){
		if(*p==X){
			ListDelete(&L,i,&e);
			printf("第%d个元素，其值为%d，已删除！
",i,e);
		}
	}
	putchar('
');
	
	printf("删除元素值为x的元素之后顺序线性表内容为：
");
	OutputList(&L);
	putchar('
');
	
	getch();
	return0;	
}

运行结果

⑽ 求助，线性表的销毁

销毁是头结点都没有了，不存在了，置空还有个头结点吧