郝斌數據結構--鏈表

模塊一：線性結構

連續存儲【數組】

1.數組定義

元素類型相同, 大小相等

2.數組的優缺點

# include <stdio.h>
# include <malloc.h>
# include <stdlib.h>
# include <stdbool.h>
//定義了一個數據類型，struct Arr
struct Arr
{
	int *pBase; //存儲的使數組的第一個元素的地址
	int len; //數組所能容納的最大元素的個數
	int cnt; // 當前數組有效元素的個數
};

void init_arr();
bool append_arr(struct Arr *pArr, int val);
bool insert_arr(struct Arr *pArr, int pos,  int val);
bool delete_arr(struct Arr *pArr, int pos, int *val);
bool is_empty(struct Arr *pArr);
bool is_full(struct Arr *pArr);
void sort_arr(struct Arr *pArr);
void show_arr(struct Arr *pArr);
void inversion_arr(struct Arr *pArr);

int main(void)
{
	struct Arr arr; //定義了一個變量
	int val;
	init_arr(&arr, 6);
	append_arr(&arr, 3);
	append_arr(&arr, 5);
	append_arr(&arr, 6);
	//append_arr(&arr, 8);
	append_arr(&arr, 1);
	//append_arr(&arr, 6);
	insert_arr(&arr, 4, 9);
	if (delete_arr(&arr, 3, &val))
		printf("元素%d刪除成功\n", val);
	else
		printf("刪除操作失敗\n"); 
	show_arr(&arr);
	sort_arr(&arr);
	show_arr(&arr);
	inversion_arr(&arr);
	show_arr(&arr);
	return 0;
}

void init_arr(struct Arr *pArr, int length)
{
	pArr->pBase = (int *)malloc(sizeof(int) * length);
	if (NULL == pArr->pBase)
	{
		printf("動態內存分配失敗！\n");
		exit(-1); //終止整個程序
	}
	else
	{
		pArr->len = length;
		pArr->cnt = 0;
	}
	return;
}

bool is_empty(struct Arr *pArr)
{
	if (0 == pArr->cnt)
		return true;
	else
		return false;
}
bool is_full(struct Arr *pArr)
{
	if (pArr->cnt == pArr->len)
		return true;
	else
		return false;
}
void show_arr(struct Arr *pArr)
{
	if (is_empty(pArr))
		printf("數組爲空\n");
	else
	{
		for (int i = 0; i < pArr->cnt; ++i)
			printf("%d ", pArr->pBase[i]);
	}
	printf("\n");
}

bool append_arr(struct Arr *pArr, int val)
{
	if (is_full(pArr))
		return false;
	else
		pArr->pBase[pArr->cnt] = val;
		pArr->cnt++;
}

bool insert_arr(struct Arr *pArr, int pos, int val)
{
	if (is_full(pArr))
	{
		printf("數組已滿\n");
		return false;
	}
	if (pos<1 || pos>pArr->cnt+1)
	{
		printf("pos 參數不合法\n");
		return false;
	}
	for (int i = pArr->cnt - 1; i >= pos - 1; i--)    //  3 5 6 1 8
	{
		pArr->pBase[i + 1] = pArr->pBase[i];
	}
	pArr->pBase[pos-1] = val;
	pArr->cnt++;
	return ;
}

bool delete_arr(struct Arr *pArr, int pos, int *val)
{
	if (is_empty(pArr))
	{
		printf("數組爲空\n");
		return false;
	}
	if (pos < 1 || pos > pArr->cnt)
	{
		printf("pos 參數不合法\n");
		return false;
	}
	*val = pArr->pBase[pos - 1];
	
	for (int i = pos; i < pArr->cnt; i++)    //  3 5 6 1 9
	{
		pArr->pBase[i-1] = pArr->pBase[i];
	}
	pArr->cnt--;

}
void sort_arr(struct Arr *pArr)
{
	int tmp;
	for (int i = 0; i < pArr->cnt; i++)
	{
		for (int j = i+1; j < pArr->cnt; j++)
		{
			if (pArr->pBase[i] > pArr->pBase[j])
			{
				tmp = pArr->pBase[i];
				pArr->pBase[i] = pArr->pBase[j];
				pArr->pBase[j] = tmp;

			}
		}
	}
}
void inversion_arr(struct Arr *pArr)
{
	int tmp;
	for (int i = 0, j = pArr->cnt - 1; i < j; i++, j--)
	{
		tmp = pArr->pBase[i];
		pArr->pBase[i] = pArr->pBase[j];
		pArr->pBase[j] = tmp;
	}
}

 

預備知識 typedef用法

typedef struct Student{

int id;

int age;

}ST; // 爲數據類型起新的名字

typedef struct Student{

int id;

int age;

}* PST; //PST等價於struct Student *

typedef struct Student{

int id;

int age;

}* PST ST; //等價於 PST代表了struct Student *, ST代表了struct Student

離散存儲【鏈表】

定義：n個節點離散分配，彼此通過指針相連，每個節點只有一個前驅結點、一個後續節點，

首節點沒有前驅節點 尾節點沒有後續節點

# include <stdio.h>

 

typedef struct Node

{

int data; //數據域

struct Node *pNext; //指針域

}NODE, *PNODE;//NODE等價於 struct Node， PNODE等價於struct Node*

 

int main(void)

{

return 0;

}

專業術語：

• 首節點 第一個有效節點
• 尾節點 最後一個有效節點
• 頭節點 第一個有效節點之前的那個節點
•            頭節點並不存放有效數據
•            頭節點的數據類型與其他的節點的數據類型相同
•            加頭節點的目的主要爲了對鏈表的操作
• 頭指針 指向頭節點的指針變量
• 尾指針 指向尾節點的指針變量

 

分類：

• 單鏈表
• 雙鏈表 每一個節點又兩個指針域
• 循環鏈表 能通過一個節點找到其他的所有的節點
• 非循環鏈表

 

算法：

• 遍歷
• 查找
• 清空
• 銷燬
• 求長度
• 排序
• 刪除節點
• 插入節點

 非循環鏈表的插入的僞算法

（1）r = p->pNext;

（2）p->pNext = q;

（3）q->pNext = r;

 

 如何把q指向的結點放在p指向節點的後面（看圖再看下面的步驟）

（1）取出p所指向的結點的指針域

（2）p的指針域指向q

（3）把p的指針域的值（指向p後面的一個元素）賦值給q的指針域，

 則q就指向p後面的一個元素

 

第二種方法（看同目錄下的圖）

 q->pNext = p->pNext;

p->pNext = q;

（1）先使q指向後面一個結點（後面一個結點的地址存放在p的指針域部分）

（2）使p的指針域指向q

（q不是結點，,是一個指針變量，存放了節點的地址）

 

 

    

 

 

刪除一個非循環鏈表的節點的僞算法

r = p->pNext;

 p->pNext = p->pNext->pNext;//這樣寫會導致內存泄漏，所以需要釋放

free(r);

 

 刪除一個鏈表的結點

（1）找不到第二個結點的地址，所以就不能釋放，所以需要先指向然後釋放

（2） p->pNext->pNext        //p指針域指向的元素的指針域。

# include <stdio.h>
# include <malloc.h>
# include <stdlib.h>
# include <stdbool.h>
typedef struct Node
{
	int data; //數據域
	struct Node *pNext; //指針域
}NODE, *PNODE;//NODE等價於 struct Node， PNODE等價於struct Node*
void traverse_list(PNODE pHead);
PNODE create_list(void);
bool is_empty(PNODE pHead);
int length_list(PNODE pHead);
bool insert_list(PNODE pHead, int pos, int val);
bool delete_list(PNODE pHead, int pos, int *pval);
void sort_list(PNODE pHead);


int main(void)
{
	PNODE pHead = NULL; //等價於struct Node* pHead = NULL；
	pHead = create_list(); //create_list()功能， 創建一個非循環單鏈表，並將該鏈表的頭節點的地址賦給pHead
	int len;
	int val;
	if (is_empty(pHead))
	{
		return;
	}
	else
	{
		len = length_list(pHead);
		printf("鏈表的長度爲%d\n", len);
		traverse_list(pHead);
		sort_list(pHead);
		traverse_list(pHead);
		if (delete_list(pHead, 5, &val))
		{
			printf("刪除元素%d成功！\n", val);
		}
		else
		{
			printf("刪除元素失敗！\n");

		}
		traverse_list(pHead);
		if (insert_list(pHead, 5, 66))
		{
			printf("插入元素成功\n");
			traverse_list(pHead);

		}
		else
		{
			printf("插入元素失敗\n");
		}
	}

	return 0;
}

PNODE create_list(void)
{
	int len;
	int val;
	PNODE pHead = (PNODE)malloc(sizeof(NODE));
	if (pHead == NULL)
	{
		printf("內存分配失敗，程序終止！\n");
		exit(-1);
	}
	PNODE pTail = pHead;
	pTail->pNext = NULL;
	printf("請輸入鏈表節點的個數：len= ");
	scanf_s("%d", &len);
	for (int i = 0; i < len; i++)
	{
		PNODE pNew = (PNODE)malloc(sizeof(NODE));
		if (pNew == NULL)
		{
			printf("內存分配失敗，程序終止！\n");
			exit(-1);
		}
		printf("請輸入%d個鏈表數據", i + 1);
		scanf_s("%d", &val);
		pTail->pNext = pNew;
		pNew->data = val;
		pNew->pNext = NULL;
		pTail=pNew;
	}
	return pHead;

}

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

bool is_empty(PNODE pHead)
{
	PNODE p = pHead;
	if (p->pNext == NULL)
	{
		printf("鏈表爲空！\n");
		return true;
	}
	else
	{
		return false;
	}
}
int length_list(PNODE pHead)
{
	PNODE p = pHead;
	int len=0;
	while (p->pNext != NULL)
	{
		++len;
		p = p->pNext;
	}
	return len;
}


void sort_list(PNODE pHead)
{
	PNODE p;
	PNODE q;
	int i, j, t;
	int len = length_list(pHead);
	for (i=0, p=pHead->pNext;  i<len-1; p=p->pNext, i++)
	{
		for (j=i+1, q=p->pNext; j<len; q=q->pNext, j++)
		{
			if (p->data > q->data)
			{
				t = p->data;
				p->data = q->data;
				q->data = t;
			}
		}
	}
}
bool insert_list(PNODE phead, int pos, int val)
{
	PNODE p = phead;
	int i = 0;
	while (NULL!=p && i<pos-1)
	{
		p = p->pNext;
		i++;
	}
	if (NULL==p && i>pos-1)
		return false;
	PNODE pNew = (PNODE)malloc(sizeof(NODE));
	if (NULL == pNew)
	{
		printf("內存分配失敗\n");
		exit(-1);
	}
	pNew->pNext = p->pNext;
	pNew->data = val;
	p->pNext = pNew;
	return true;
}
bool delete_list(PNODE pHead, int pos, int *pval)
{
	PNODE p = pHead;
	int i = 0;
	while (NULL!=p->pNext && i<pos-1)
	{
		p = p->pNext;
		i++;
	}
	if (i>pos-1 || NULL==p->pNext)
		return false;
	//刪除操作
	PNODE q = p->pNext;

	*pval = q->data;
	p->pNext = p->pNext->pNext;
	free(q);
	return true;
}