2. 程式人生 > >資料結構之鏈式表

資料結構之鏈式表

阿新 • • 發佈：2018-12-09
        繼順序表之後，我們需要討論一下資料結構的鏈式表。順序表的特點是邏輯上相鄰的元素在物理位置上也相鄰，通常我們用陣列來表示這種儲存結構，這種儲存結構簡單，易於理解。但是同時必須看到它的缺點，那就是在作 插入和刪除操作時，需要移動大量的資料 ，這必然造成效率低下。因此，產生了鏈式表，鏈式表不需要邏輯上相鄰的元素在物理位置上也相鄰，因此效率大大提高。另一方面，連結串列不需要像順序表那樣對空間進行預先的分配規劃，而可以由程式設計師根據需求即時生成並且適時釋放，因而這種方式實際上可以更為高效的利用緊缺的儲存空間，這也是它被廣泛使用的原因。也正是如此，連結串列比順序表理解起來要更加複雜。

       鏈式表主要分為線性連結串列，靜態連結串列，迴圈連結串列和雙向連結串列。一開始一定要搞清楚每一種連結串列的資料結構定義。        鏈式表的特點是用一組任意的儲存單元儲存線性表的資料元素，因為這些儲存單元在物理上不一定是連續的，所以每一個數據元素除了包含資料資訊外，還需要包含至少其它元素的位置資訊。我們稱這樣的儲存單元為 結點，節點由資料域和指標域組成。         線性連結串列的節點中只包含一個指標域，因此又成為單鏈表。單鏈表最後一個結點的指標域為NULL.這個和迴圈連結串列是不同的。        單鏈表的資料結構可以定義為        typedef struct LNode{             ElemType data;
            struct LNode *next;
       }LNode,*LinkList;
       一般來說，單鏈表都包含一個頭節點，頭節點可以不儲存任何資訊，也可以儲存諸如線性表的長度等附加資訊。        靜態連結串列
是用陣列來進行描述的連結串列這種方法便於在不設“指標”型別的高階程式設計語言中來使用。       靜態連結串列的資料結構定義如下：       #define MAXSIZE 1000       typedef struct{
          ElemType data;
          int cur;
    }component,SLinkList[MAXSIZE];
      這種方式仍然需要事先分配一個較大的空間，但是仍然具有線性連結串列的在插入刪除等操作方面的優點。不過個人感覺沒有指標那麼靈活，用的不是很多，不作為優先選擇。        迴圈連結串列
的特點是表中最後一個結點的指標域指向頭節點，整個連結串列形成一個環。因此，從表中的任意一個結點出發均可以找到表中的其他節點。       迴圈連結串列的資料結構和雙向連結串列是相同的。       由於以上的連結串列結構只有一個指示直接後繼的指標域，因此從某個結點出發只能往後查詢其它結點，如果查詢該之前的節點，則只能從表頭查起，效率顯然很低。為了克服這種缺點，出現了雙向連結串列。       雙向連結串列具有連個指標域，一個指向直接後繼，一個指向直接前驅。       雙向連結串列的資料結構定義如下：       typedef struct DulNode{           ElemType data;           struct DulNode *prior;           struct DulNode *next;       }DulNode, *DuLinkList;       注意，雙向連結串列也有迴圈表，並且有兩個環。       
      由於連結串列在空間上的合理利用和插入、刪除操作上的有點，在很多場合都作為首先的儲存結構。但是由於實際應用的不同，我們必須要 合理的定義和使用連結串列的儲存結構，做到靈活處理，而不能生搬硬套。        以下是根據實際應用定義的線性連結串列的型別和抽象資料型別的實現，可以作為參考。        線性連結串列的資料結構型別定義：         
typedef struct LNode
{
	ElemType data;
	struct LNode *next;
}LNode,*Link, *Position;

typedef struct
{ 
	Link head,tail;
	 int len;
 }LinkList;
     
/* 
Description: allocate a node which is pointed by p and the value of the node is e.
*/
Status MakeNode(Link &p, ElemType e)
{
	p = (Link)malloc(sizeof(LNode));
	if(p == NULL)
	{
		return ERROR;
	}
	p->data = e;
	p->next = NULL;
	return OK;
}

/*
Description: construct a vacant linear list which only has a head node.
*/
Status InitList(LinkList &L)
{
	int e = 0;
	MakeNode(L.head,e);
	L.len = 0; // the length of a Linear List is zero.
	L.tail = L.head;
	return OK;
}

/*
Description: release the space pointed by p.
*/
Status FreeNode(Link &p)
{
	free(p);
	return OK;
}

/* 
Description: destroy Linear List L and it doesn't exist anymore.
*/
Status DestroyList(LinkList &L)
{
	int i;
	Link p;
	Link s;
	for(i=0;i<L.len;i++)
	{
		p = L.head->next;
		s = p->next;
		FreeNode(p);
		L.head->next = s;
	}
	FreeNode(L.head);
	return OK;
} 

/*
Description: Make the List become a vacant list and release the space.
*/
Status ClearList(LinkList &L)
{
	DestroyList(L);
	InitList(L);
	return OK;
}

/*
Description: if h pointed to the head node, insert node s before the first node.
*/
Status InsFirst(Link h, Link s)
{
	s->next = h->next;
	h->next = s;
	return OK;
}

/*
Description: delete the first node in the Linear List and return the address by p.
*/
Status DelFirst(Link h, Link &p)
{
	Link s;
	s = h->next;
	h->next = s->next;
	s->next = NULL;//remember to modify point s->next, as s has already lose relation with the primary list.
	p = s;
	return OK;
}

/*
Description: Link the nodes beginning with s to the end of L and modify the tail of L.
			 use point p to trace s.
*/
Status Append(LinkList &L, Link s)
{
	Link p = NULL;
	L.tail->next = s;// this is very important, we must link s to L.
	p = s;
	s = s->next;
	while(s)
	{
		p = s;
		s = s->next;
	}
	L.tail = p;
	return OK;
}

/*
Description: remove the tail of Linear List L and return the tail address by q, modify the tail of Linear L.
*/
Status Remove(LinkList &L, Link &q)
{
	Link s;
	q = L.tail;
	s = L.head->next;
	while(s->next != L.tail)
	{
		s = s->next;
	}
	FreeNode(L.tail);
	s->next = NULL;
	L.tail = s;
	return OK; 
}

/*
Description: add the node pointed by s to the position that is previous to the node pointed by p in the Linear List L.
			 modify the point p and make it pointed to the new inserted node.
*/
Status InsBefore(LinkList &L, Link &p, Link s)
{
	Link k;
	k = L.head->next;
	while(k->next != p)
	{
		k = k->next;
	}
	k->next = s;
	s->next = p;
	p = s;
	return OK;
}

/*
Description: Insert the node into the position after the node pointed by p. Modify the point p.
*/
Status InsAfter(LinkList &L, Link &p, Link s)
{
	s->next = p->next;
	p->next = s;
	p = s;
	return OK;
}

/*
Description: renew the element pointed by p with e.
*/
Status SetCurElem(Link &p, ElemType e)
{
	p->data = e;
	return OK;
}

/*
Description: return the element pointed by p.
*/
ElemType GetCurElem(Link p)
{
	return p->data;
}

/*
Description: if List L is a vacant list, return true, or return false.
*/
Status ListEmpty(LinkList L)
{
	if(L.len == 0)
	{
		return OK;
	}
	else
	{
		return ERROR;
	}
}

/*
Description: return the number of the element in the Linear List.
*/
int GetListLength(LinkList L)
{
	return L.len;
}

/*
Description: Get the position of the head node in the Linear List.
*/
Position GetHead(LinkList L)
{
	return L.head;
}

/*
Description: Get the position of the last node in the Linear List.
*/
Position GetLast(LinkList L)
{
	return L.tail;
}

/*
Description: Get the position which is previous to the node pointed by p.
*/
Position PriorPos(LinkList L, Link p)
{
	Link k;
	k = L.head;
	while(k->next != p && k->next != NULL)
	{
		k = k->next;
	}
	if(k->next == p)
	{
		return k;
	}
	else 
	{
		return NULL;
	}
}

/*
Description: Get the position next to the node pointed by p.
*/
Position NextPos(LinkList L, Link p)
{
	if(p->next != NULL)
	{
		return p->next;
	}
	else 
	{
		return NULL;
	}
}

/*
Description: return the position of the node i in the Linear List using p and return OK. if i is invalid, return ERROR. 
*/
Status LocatePos(LinkList L, int i, Link &p)
{
	int j = 1;
	Link k = L.head->next;
	if(i<1 || i>L.len)
	{
		return ERROR;
	}
	while(k!= NULL && j != i)
	{
		j++;
		k = k->next;
	}
	p = k;
	return OK;
}

/*
Description: return the position of the node whose element fits the  compare relationship with element e in the list. 
*/
Position LocateElem(LinkList L, ElemType e, Status(*compare)(ElemType, ElemType))
{
	Link k;
	k = L.head->next;
	while(!compare(k->data,e) && k!= NULL)
	{
		k = k->next;
	}
	if(k == NULL)
	{
		return NULL;
	}
	return k;
}

/*
Description: use the function visit() to process every element in the List. If visit() returns ERROR, then the function return
			 ERROR.
*/
Status ListTraverse(LinkList L, Status(*visit)(ElemType))
{
	Link s;
	s = L.head->next;
	while((visit(s->data)) && (s!=NULL))
	{
		s = s->next;
	}
	if(s == NULL)
	{
		return OK;
	}
	else
	{
		return ERROR;
	}
}
以下是一個測試程式： 已知連結串列La,Lb中的元素按照非遞減的順序排列，歸併La,Lb到新的連結串列Lc,使Lc中的元素也按照非遞減的順序排列。 
int compare(ElemType a, ElemType b)
{
	if(a <= b)
	{
		return ERROR;
	}
	else
	{
		return OK;
	}
}
/*
Description: insert the elment e into the position i in the List
*/
Status ListInsert_L(LinkList &L, int i, ElemType e)
{
	Link h,s;
	if(!LocatePos(L,i-1,h))
	{
		return ERROR;
	}
	if(!MakeNode(s,e))
	{
		return ERROR;
	}
	InsFirst(h,s);
	return OK;
}

/*
Description: Merge La and Lb into List Lc. The elements in Lc grow from small to big.
*/
Status MergeList_L(LinkList &La, LinkList &Lb, LinkList &Lc, int(*compare)(ElemType, ElemType))
{
	Link ha = NULL;
	Link hb = NULL;
	Link pa = NULL;
	Link pb = NULL;
	Link q = NULL;
	int a,b;
	if(!InitList(Lc))
	{
		return ERROR;
	}
	ha = GetHead(La);
	hb = GetHead(Lb);
	pa = NextPos(La,ha);
	pb = NextPos(Lb,hb);
	while(pa && pb)
	{
		a = GetCurElem(pa);
		b = GetCurElem(pb);
		if((*compare)(a,b) <= 0)
		{
			DelFirst(ha,q);
			Append(Lc,q);
			pa = NextPos(La,ha);
		}
		else
		{
			DelFirst(hb,q);
			Append(Lc,q);
			pb = NextPos(Lb,hb);
		}
	}
	if(pa)
	{
		Append(Lc,pa);
	}
	else
	{
		Append(Lc,pb);
	}
	FreeNode(ha);
	FreeNode(hb);
	return OK;
}

void main(void)
{
	int i = 0;
	int ea = 6;
	int eb = 4;
	Link p = NULL;
	Link s = NULL;
	LinkList La,Lb,Lc;
	La.head = NULL;
	La.tail = NULL;
	Lb.head = NULL;
	Lb.tail = NULL;
        //Creat the list La,Lb.
        InitList(La); 
	InitList(Lb);
	for(i=0;i<ListLength;i++)
	{
		MakeNode(p,ea++);
		Append(La,p);
		La.len++;
	}
	for(i=0;i<ListLength;i++)
	{
		MakeNode(p,eb++);
		Append(Lb,p);
		Lb.len++;
	}
	p = La.head->next;
	while(p!=NULL)
	{
		cout << p->data;
		p = p->next;
	}
	cout<< endl;
	p = Lb.head->next;
	while(p!=NULL)
	{
		cout << p->data;
		p = p->next;
	}
	cout<< endl;
	MergeList_L(La,Lb,Lc,compare);//the function name can be used as the parameter to transfer.
	s = Lc.head->next;
	while(s != NULL)
	{
		printf("%d",s->data);
		s = s->next;
	}

}



在過程中碰到的問題都是關於地址的，連結串列中最重要的也是地址問題。非常重要的一點是，因為記憶體是由我們自己分配和管理的，如果我們不進行釋放，那麼記憶體中的資料是不會改變的。我們是按照 地址來操作該地址所對應的記憶體空間中的內容。        




       

相關推薦

資料結構之鏈式表

        繼順序表之後，我們需要討論一下資料結構的鏈式表。順序表的特點是邏輯上相鄰的元素在物理位置上也相鄰，通常我們用陣列來表示這種儲存結構，這種儲存結構簡單，易於理解。但是同時必須看到它的缺點，那就是在作 插入和刪除操作時，需要移動大量的資料 ，這

資料結構之鏈式表的實現--單鏈表(C語言)

學習參考: 嚴蔚敏: 《資料結構-C語言版》 基本操作: 單鏈表的建立 新增結點(頭插法) 新增結點(尾插法) 單鏈表的輸出 單鏈表的修改 單鏈表的插入 單鏈表的刪除 單鏈表按

資料結構之鏈式表的實現--單向迴圈連結串列(C語言)

 學習參考: 嚴蔚敏: 《資料結構-C語言版》 單向迴圈連結串列的基本操作 單向迴圈連結串列的建立 單向迴圈連結串列新增結點(頭插法) 單向迴圈連結串列新增結點(尾插法) 單向迴圈連結串列

C++資料結構之鏈式佇列模版實現

鏈佇列的儲存結構 　　將對頭指標front指向鏈佇列的頭結點（頭節點為空，不存資料），隊尾指標rear指向終端結點。元素從隊尾進入，隊首出列。 元素為空時，隊尾指標指向隊頭指標。 鏈式佇列模版實現： 功能： 1 建立 2 遍歷 4 入隊，出隊 5 獲取

資料結構之鏈式棧

#include<stdio.h> #include<stdlib.h> typedef int Elemtype; typedef struct node        //定義結點 {     Elemtype data;     struct n

資料結構之-鏈式棧及其常見應用（進位制轉換、括號匹配、行編輯程式、表示式求值等）

1、棧的概念 棧（stack）又名堆疊，它是一種運算受限的線性表。其限制是僅允許在表的一端進行插入和刪除運算。這一端被稱為棧頂，相對地，把另一端稱為棧底。向一個棧插入新元素又稱作進棧、入棧或壓棧，它是把新元素放到棧頂元素的上面，使之成為新的棧頂元素；從一個棧刪除元素又稱作出棧或退棧，它是把棧

資料結構之鏈式佇列

上一篇我們講了，順序佇列，那我們如何用連結串列實現一個佇列呢。 下面來看 #pragma once #include<stdio.h> #include<stdlib.h> #include<stddef.h> #de

資料結構之鏈式棧的一些基本操作

鏈式棧是一種資料儲存結構，可以通過單鏈表的方式來實現，使用鏈式棧的優點在於它能夠克服用陣列實現的順序棧空間利用率不高的特點，但是需要為每個棧元素分配額外的指標空間用來存放指標域。 標頭檔案 LinkS

PTA-資料結構 求鏈式線性表的倒數第K項

7-24 求鏈式線性表的倒數第K項 （20 分） 給定一系列正整數，請設計一個儘可能高效的演算法，查詢倒數第K個位置上的數字。 輸入格式: 輸入首先給出一個正整數K，隨後是若干正整數，最後以一個負整數表示結尾（該負數不算在序列內，不要處理）。 輸出格式: 輸出倒數第

《資料結構》鏈式有序表的合併

 鏈式有序表的合併 演算法思想： 設立三個指標，pa,pb,pc,其中pa和pb分別指向La表和LB表當前待比較結點，而pc指向LC白哦當前最後一個結點。 指標的初始值：pa和pb分別指向LA和LB表第一個結點，pc指向空表LC的頭結點；然後比較指標a和pb所指向的元素的值

數據結構之鏈式隊列(C實現)

num 返回 創建 位置 刪除 () temp 結點 pan linkqueue.h #ifndef LINKQUEUE_H #define LINKQUEUE_H #include <stdio.h> #include <malloc.h>

資料結構之靜態單鏈表

靜態連結串列L儲存 遊標 cur 5 2 3 4 0 6 7 .... 1 資料 data   A

資料結構　鏈式佇列C/C++

列隊分為鏈式儲存　與　順序儲存 下面給出小編寫的順序儲存的連結https://blog.csdn.net/qq_40990854/article/details/82846939 這篇是小編寫的鏈式儲存。 思路： 佇列是一個先進先出的特點，在連結串列的表頭　head作為固定不動的

資料結構之廣義線性表

陣列（定義、順序儲存結構） 矩陣的壓縮儲存 廣義表 陣列的順序儲存（將二維的陣列壓縮要一維儲存） 行優先，低下標（aij的位序為k<以1作為開始>，每行n個元素)： k = (i - 1) * n + (j - 1) + 1 = (i

資料結構三——鏈式儲存結構

●   鏈式儲存結構     特點：用一組任意的儲存單元儲存線性表的資料元素，可以連續也可以不連續，不僅含有資料元素還要有前驅、後繼元素的地址。               &nbs

資料結構之靜態順序表和動態順序表

@Sock對靜態順序表和動態順序表的總結 簡單概括他們的異同點 相同點:記憶體空間連續, 資料順序儲存 不同點:它們所佔記憶體空間的位置不同, 靜態定義一個順序表, 順序表所佔的記憶體空間開闢在記憶體的靜態區, 即所謂的函式棧上, 隨著函式呼叫的結束, 這塊記憶體區域會被系統自動

資料結構之動態順序表

動態順序表 動態順序表是跟靜態順序表大體相似，有些地方是不同的，動態順序表是在動態變化中，當我們的所需的記憶體不夠時，它會自動開闢一個我們需要的空間，來供我們使用。 動態順序表與靜態順序表的不同在於初始化/銷燬/所有插入，其他和靜態順序表完全一樣。 定義一個結構體 先將我們需

資料結構之靜態順序表

title: 資料結構之靜態順序表 date: 2018-11-09 14:21:51 tags: C-資料結構 靜態順序表屬於資料結構開始的一種基本結構 首先我們要知道資料結構的概念 資料結構 資料的組織關係 演算法 為了達到特定的目的的一系列過程。在這個過程中又

資料結構【鏈式前向星】

第一次接觸鏈式前向星是在學習圖論的迪傑斯特拉演算法時，大佬們紛紛用鏈式前向星+堆優化+迪傑斯特拉解題，秀的我萌新懵的一批，當時不知道啥是鏈式前向星，不過隨著越來越深入，這種結構見得越來越多，慢慢的就明白了。 在儲存一個圖時，我們經常用的應該是矩陣，不過他比較浪費空間，尤其是稀疏圖，點又多，空間經

資料結構之雜湊表與連結串列、陣列

雜湊表 主要描述雜湊表的定義：通過關鍵碼尋找值的資料對映結構，類似於查字典 當存在雜湊衝突時，有兩種常用的方式：開發定址法和鏈地址法 開發定址法通俗的來說就是判斷該地址是否存資料，沒存就放進去，存了就找下一個地址，依次類推，問題是如果空間不足，無法處理衝突。 鏈地