C語言之——鏈表（一）

一、什麼是鏈表？

要想搞懂鏈表，要從數組的兩個缺陷談起。數組有兩個缺陷：初始化時要規定長度，且一旦確定後期不能更改；數組的元素的數據類型必須一致。爲了克服第二個缺陷，我們發明了結構體；爲了克服第一種缺陷，我們發明了鏈表。我們可以這樣理解：鏈表就是一個元素個數可以實時變大/變小的數組。

鏈表就是用鎖鏈連接起來的表。這裏的表指的是一個一個的節點，節點中有一些內存可以用來存儲數據，叫做數據域，一些內存存儲指向下一個節點的指針，叫做指針域。

一個簡答的鏈表結構示意圖如下所示：

• 首元節點（又叫做首節點）：第一個有效節點
• 尾節點：最後一個有效節點
• 頭節點：是首節點前面的那個節點，數據類型和首節點一樣，但是頭結點並不存放有效數據，加頭結點是爲了方便對鏈表的操作
• 頭指針：指向頭節點的指針
• 尾指針：指向尾節點的指針

 

鏈表的分類：

• 單鏈表
• 雙鏈表：一個節點裏面有兩個指針域，左邊的指針域指向上一個節點，右邊的指針域指向下一個節點
• 循環列表：能通過任何一個節點找到其他所有節點
• 非循環列表

 

二、如何創建一個鏈表？

1、鏈表節點的表示

typedef struct Node
{
	int data;//數據域
	struct Node *pNext;//指針域
}NODE, *PNODE;//NODE等價於struct Node類型，PNODE等價於struct Node *類型

2、創建一個鏈表

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


// 構建一個鏈表的節點
struct node
{
	int data;				// 有效數據
	struct node *pNext;		// 指向下一個節點的指針
};

// 作用：創建一個鏈表節點
// 返回值：指針，指針指向我們本函數新創建的一個節點的首地址
struct node * create_node(int data)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	if (NULL == p)
	{
		printf("malloc error.\n");
		return NULL;
	}
	// 清理申請到的堆內存
	bzero(p, sizeof(struct node));
	// 填充節點
	p->data = data;
	p->pNext = NULL;	
	
	return p;
}

// 思路：由頭指針向後遍歷，直到走到原來的最後一個節點。原來最後一個節點裏面的pNext是NULL，現在我們只要將它改成new就可以了。添加了之後新節點就變成了最後一個。
void insert_tail(struct node *pH, struct node *new)
{
	// 分兩步來完成插入
	// 第一步，先找到鏈表中最後一個節點
	struct node *p = pH;
	while (NULL != p->pNext)
	{
		p = p->pNext;				// 往後走一個節點
	}
	
	// 第二步，將新節點插入到最後一個節點尾部
	p->pNext = new;
}

int main(void)
{
	// 定義頭指針
	struct node *pHeader = create_node(1);
	
	insert_tail(pHeader, create_node(2));
	insert_tail(pHeader, create_node(3));
	insert_tail(pHeader, create_node(4));

	return 0;
}

三、如何遍歷一個鏈表？

只要知道一個鏈表的頭指針，就可以對整個鏈表進行訪問：

void traverse_list( PNODE pHead )
{
	PNODE p = pHead->pNext;
	
	while( NULL != p )
	{
		printf( " %d ", p->data );
		p = p->pNext;
	}
	printf( " \n " );
	
	return;//意思是告訴別人程序已經結束
}

 

四、如何插入一個節點？

如圖所示：想在p節點後面插入一個q節點

 可以採用兩種方式：

（1）

 r = p->pNext; //必須先保存起來

p->pNext = q;  //將p節點的指針域指向新插入的節點

q->pNext = r;

（2）

q->pNext = p->pNext;  

p->pNext = q;

五、如何刪除一個節點

 r = p->pNext;//將p節點指針域指向的地址保存
p->pNext = p->pNext->pNext;
free(r);//一定要釋放堆內存

 

六、綜合代碼示例：

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

typedef struct Node
{
	int data; //數據域
	struct Node * pNext; //指針域
}NODE, *PNODE; //NODE等價於struct Node    PNODE等價於struct Node *

//函數聲明
PNODE create_list(void);  //創建鏈表
void traverse_list(PNODE pHead);  //遍歷鏈表
bool is_empty(PNODE pHead);  //判斷鏈表是否爲空
int length_list(PNODE);  //求鏈表長度
//在pHead所指向鏈表的第pos個節點的前面插入一個新的結點，該節點的值是val， 並且pos的值是從1開始
bool insert_list(PNODE pHead, int pos, int val);  

//刪除鏈表第pos個節點，並將刪除的結點的值存入pVal所指向的變量中,  並且pos的值是從1開始
bool delete_list(PNODE pHead, int pos, int * pVal);  
void sort_list(PNODE);  //對鏈表進行排序


int main(void)
{
	PNODE pHead = NULL; //等價於 struct Node * pHead = NULL;
	int val;

	pHead = create_list();  //create_list()功能：創建一個非循環單鏈表，並將該鏈表的頭結點的地址付給pHead
	traverse_list(pHead);
	
	//insert_list(pHead, -4, 33);
	if ( delete_list(pHead, 4, &val) )
	{
		printf("刪除成功，您刪除的元素是: %d\n", val);
	}
	else
	{
		printf("刪除失敗!您刪除的元素不存在!\n");
	}

	traverse_list(pHead);
	
	//int len = length_list(pHead);
	//printf("鏈表的長度是%d\n", len);

	//sort_list(pHead);
	//traverse_list(pHead);
	
/*	if ( is_empty(pHead) )
		printf("鏈表爲空!\n");
	else
		printf("鏈表不空!\n");
*/
	return 0;
}

PNODE create_list(void)
{
	int len;  //用來存放有效節點的個數
	int i;
	int val; //用來臨時存放用戶輸入的結點的值

	//分配了一個不存放有效數據的頭結點
	PNODE pHead = (PNODE)malloc(sizeof(NODE));
	if (NULL == pHead)
	{
		printf("分配失敗, 程序終止!\n");
		exit(-1);
	}
	PNODE pTail = pHead;//定義一個pTail，使得pTail 始終指向最後一個節點
	pTail->pNext = NULL;

	printf("請輸入您需要生成的鏈表節點的個數: len = ");
	scanf("%d", &len);
	
	for (i=0; i<len; ++i)
	{
		printf("請輸入第%d個節點的值: ", i+1);
		scanf("%d", &val);
		
		PNODE pNew = (PNODE)malloc(sizeof(NODE));
		if (NULL == pNew)
		{
			printf("分配失敗, 程序終止!\n");
			exit(-1);
		}
		pNew->data = val;
		pTail->pNext = pNew;
		pNew->pNext = NULL;
		pTail = pNew;//使得pTail始終指向最後一個節點
	}
	
	return pHead;
}

void traverse_list(PNODE pHead)
{
	PNODE p = pHead->pNext;

	while (NULL != p)
	{
		printf("%d  ", p->data);
		p = p->pNext;
	}
	printf("\n");
	
	return;
}

bool is_empty(PNODE pHead)
{
	if (NULL == pHead->pNext)
		return true;
	else
		return false;
}

int length_list(PNODE pHead)
{
	PNODE p = pHead->pNext;
	int len = 0;

	while (NULL != p)
	{
		++len;
		p = p->pNext;
	}

	return len;
}

void sort_list(PNODE pHead)
{
	int i, j, t;
	int len = length_list(pHead);
	PNODE p, q;
	
	for (i=0,p=pHead->pNext; i<len-1; ++i,p=p->pNext)
	{
		for (j=i+1,q=p->pNext; j<len; ++j,q=q->pNext)
		{
			if (p->data > q->data)  //類似於數組中的:  a[i] > a[j]
			{
				t = p->data;//類似於數組中的:  t = a[i];
				p->data = q->data; //類似於數組中的:  a[i] = a[j];
				q->data = t; //類似於數組中的:  a[j] = t;
			}
		}
	}

	return;
}

//在pHead所指向鏈表的第pos個節點的前面插入一個新的結點，該節點的值是val， 並且pos的值是從1開始
bool insert_list(PNODE pHead, int pos, int val)
{
	int i = 0;
	PNODE p = pHead;

	while (NULL!=p && i<pos-1)//試圖尋找第pos-1個節點   有可能越界，此時NULL==p而提前退出循環
	{
		p = p->pNext;
		++i;
	}

	if (i>pos-1 || NULL==p)
		return false;

	//如果程序能執行到這一行說明p已經指向了第pos-1個結點,但第pos-1個節點是否存在無所謂
	//分配新的結點
	PNODE pNew = (PNODE)malloc(sizeof(NODE));
	if (NULL == pNew)
	{
		printf("動態分配內存失敗!\n");
		exit(-1);
	}
	pNew->data = val;
	
	//將新的結點存入p節點的後面
	PNODE q = p->pNext;
	p->pNext = pNew;
	pNew->pNext = q;

	return true;
}


bool delete_list(PNODE pHead, int pos, int * pVal)
{
	int i = 0;
	PNODE p = pHead;

	while (NULL!=p->pNext && i<pos-1)
	{
		p = p->pNext;
		++i;
	}

	if (i>pos-1 || NULL==p->pNext)
		return false;
	
	//如果程序能執行到這一行說明p已經指向了第pos-1個結點，並且第pos個節點是存在的
	PNODE q = p->pNext;  //q指向待刪除的結點
	*pVal = q->data;  

	//刪除p節點後面的結點
	p->pNext = p->pNext->pNext;
	
	//釋放q所指向的節點所佔的內存
	free(q);
	q = NULL;
	
	return true;

}

 

 

REF:

郝斌老師課堂筆記