銷毀線性表演算法

⑴ 如何算是銷毀一個線性表

不可以直接釋放頭結點的，必須所有的結點全部釋放掉，最後釋放頭結點
如果直接將頭結點置空，會導致其它結點元素所佔空間不被有效釋放，產生內存泄露

一個比較規正的清空線性表的代碼如下：
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;	
}

運行結果

⑽ 求助，線性表的銷毀

銷毀是頭結點都沒有了，不存在了，置空還有個頭結點吧