数据结构单链表（带头结点）

因为头结点的数据成员只有一个：指针域，而有效数据节点里的数据成员不仅有数据域还有指针域，所以，直接用有效数据节点当做头结点

单链表结构体设计（包含了两种方法）：

//有效数据节点结构体设计（头结点借用）
typedef struct Node
{
	ELEM_TYPE data;//数据域   （1.头结点：不保存任何数据    2.有效数据节点：保存有效值）   
	struct Node* next;//指针域  (1.头结点：保存第一个元素的地址    2.有效数据节点：保存下一个有效元素的地址)
}Node, PNode;

/*第二种，头结点单独设计
//有效数据节点结构体设计
typedef struct Node
{
	union
	{
		int length;
		ELEM_TYPE data;//数据域  存放有效值
	};

	struct Node *next;//指针域  存放下一个有效数据节点的地址
}Node, PNode;

//头结点结构体设计：
typedef struct Head
{
	struct Node *next;//指针域  保存第一个有效数据节点的地址
}Head, *PHead;
*/

带头结点的单链表有哪些操作函数：

//初始化函数(对于头结点进行赋初值)
void Init_list(struct Node* plist);

//购买一个新节点
struct Node* BuyNode(ELEM_TYPE val);

//头插
bool Insert_head(struct Node* plist, ELEM_TYPE val);

//尾插
bool Insert_tail(struct Node* plist, ELEM_TYPE val);

//按位置插入(pos=0 相当于头插  pos==length 相当于尾插)
bool Insert_pos(struct Node* plist, int pos, ELEM_TYPE val);

//头删
bool Del_head(struct Node* plist);

//尾删
bool Del_tail(struct Node* plist);

//按位置删(pos==0 相当于头删   pos==length-1 相当于尾删（pos==length非法）)
bool Del_pos(struct Node* plist, int pos);
//按值删
bool Del_val(struct Node* plist, ELEM_TYPE val);

//获取值位置  （如果val值存在， 则返回其地址  不然返回NULL）
struct Node* Search(struct Node* plist, ELEM_TYPE val);

//判空
bool IsEmpty(struct Node* plist);

//判满  单链表不存在满这个概念

//获取单链表有效数据节点个数
int Get_length(struct Node* plist);

//清空  相当于直接调用销毁
void Clear(struct Node* plist);

//销毁1（malloc申请来的空间 全部释放掉）
void Destroy(struct Node* plist);

//销毁2
void Destroy2(struct Node* plist);

//打印
void Show(struct Node* plist);

1.初始化函数：

//初始化函数(对于头结点进行赋初值)
void Init_list(struct Node* plist)
{
	assert(plist != NULL);
	if (NULL == plist)
	{
		return;
	}
	//plist->data;  头结点的数据域不需要赋值
	plist->next = NULL;
}

2.购买一个新节点（相当于插入操作是需要申请的新节点）

struct Node* BuyNode(ELEM_TYPE val)
{
	struct Node* pnewnode = (struct Node*)malloc(1 * sizeof(struct Node));
	assert(pnewnode != NULL);
	if (pnewnode == NULL)
	{
		return NULL;
	}

	pnewnode->data = val;
	pnewnode->next = NULL;

	return pnewnode;
}

3.头插

bool Insert_head(struct Node* plist, ELEM_TYPE val)
{
	//1.判断参数合法性
	assert(plist != NULL);
	if (NULL == plist)
	{
		return false;
	}

	//2.1申请新节点 （插入一个节点， malloc申请一个节点，也可以使用购买新节点函数）
	struct Node* pnewnode = (struct Node*)malloc(1 * sizeof(struct Node));
	assert(pnewnode != NULL);
	if (pnewnode == NULL)
	{
		return false;
	}
	//2.2将val值赋值给新节点
	pnewnode->data = val;
	//pnewnode->next = NULL; //?这一步可以不写，因为第四步会对其进行操作

	//3.找到合适的插入位置  （因为是头插函数， 所以直接可以得到合适的插入位置）

	//4.插入
	pnewnode->next = plist->next;//因为plist的next域指向首元素地址
	plist->next = pnewnode;

    //插入顺序不能相反，如果先动了头结点的next的域，会丢失有效数据元素
	return true;
}

4.尾插

bool Insert_tail(struct Node* plist, ELEM_TYPE val)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return false;
	}
	//1.购买新节点
	struct Node* pnewnode = BuyNode(val);
	assert(pnewnode != NULL);
	if (pnewnode == NULL)
	{
		return false;
	}
	//2.找到合适的插入位置
	struct Node* p = plist;//因为指针p在for循环外面，还要使用，所以定义在for外面
	for (p; p->next != NULL; p = p->next);
	//此时p指向尾结点
	
	//插入
	pnewnode->next = p->next;
	p->next = pnewnode;
	return true;
}

讲一下该函数里的for循环，给出一下两种for循环，并且给出相应的功能：

for(struct Node *p=plist; p->next!=NULL; p=p->next);
//让指针p指向头结点，判断依据是下一个节点存不存在，存在的话向后走一步

for(struct Node *p=plist->next; p!=NULL; p=p->next);
//让指针p指向第一个元素地址，判断依据是当前指向的节点存不存在，存在的话向后走一步

第一个for循环可以用于插入，删除等操作。第二个可以用于查找，获取有效值个数，打印等操作

5.按位置插入(pos=0 相当于头插  pos==length 相当于尾插)

bool Insert_pos(struct Node* plist, int pos, ELEM_TYPE val)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return false;
	}
	assert(pos >= 0 && pos <= Get_length(plist));
	//if
	//1.购买新节点
	struct Node* pnewnode = BuyNode(val);
	assert(pnewnode != NULL);
	if (NULL == pnewnode)
	{
		return false;
	}
	//2.找到合适的插入位置  
	struct Node* p = plist;
	for (int i = 0; i < pos; i++)
	{
		p = p->next;
	}
	//插入
	pnewnode->next = p->next;
	p->next = pnewnode;
	return true;
}

6.头删

bool Del_head(struct Node* plist)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return false;
	}
	if (IsEmpty(plist))//删除需要判空，此函数会在后边给出
		return false;

	struct Node* p = plist;
	p = p -> next;

	plist->next = p->next;
	free(p);
	return true;
}

7.尾删

bool Del_tail(struct Node* plist)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return false;
	}
	if (IsEmpty(plist))//删除需要判空
		return false;

	struct Node* p = plist;
	for (p; p->next != NULL; p = p->next);// 此时p指向尾结点

	struct Node* q = plist;
	for (q; q->next != p; q = q->next);// 此时q停在尾结点的前面
	
	q->next = p->next;//q->next = NULL;
	free(p);
	return true;
}

思路

 8.按位置删(pos==0 相当于头删   pos==length-1 相当于尾删（pos==length非法）)

bool Del_pos(struct Node* plist, int pos)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return false;
	}
	assert(pos >= 0 && pos <= Get_length(plist));
	//if判断一下
//p和q定位给出了两种方法
	/*struct Node* p = plist;
	for (int i = 0; i <= pos; ++i)
	{
		p = p->next;
	}

	struct Node* q = plist;
	for (q; q ->next!= p; q = q->next);*/
//第二种
	struct Node* q = plist;
	for (int i = 0; i < pos; i++)
	{
		q = q->next;
	}
	struct Node* p = q->next;

	q->next = p->next;
	free(p);
	return true;
}

9.按值删

bool Del_val(struct Node* plist, ELEM_TYPE val)
{
	assert(plist != NULL);
	if (plist == NULL)
	{
		return false;
	}
	struct Node* p = Search(plist, val);
	if (p == NULL)
	{
		return false;
	}

	struct Node* q = plist;
	for (q; q->next != p; q = q->next);
	//q在待删除节点p的前面

	q->next = p->next;
	free(p);
	return true;
}

10.获取值位置  （如果val值存在， 则返回其地址  不然返回NULL）

struct Node* Search(struct Node* plist, ELEM_TYPE val)
{
	//assert
	for (struct Node* p = plist->next; p != NULL; p = p->next)
	{
		if (p->data == val)
		{
			return p;
		}
	}

	return NULL;
}

11.以下给出剩余的具体函数，销毁也给出两种方法

//判空
bool IsEmpty(struct Node* plist)
{
	//assert

	return plist->next == NULL;
}

//判满  单链表不存在满这个概念

//获取单链表有效数据节点个数
int Get_length(struct Node* plist)
{
	//assert
	int count = 0;
	for (struct Node* p = plist->next; p != NULL; p = p->next)
	{
		count++;
	}

	return count;
}

//清空  相当于直接调用销毁
void Clear(struct Node* plist)
{
	Destroy(plist);
}

//销毁1（malloc申请来的空间 全部释放掉）
void Destroy(struct Node* plist)
{
	//assert
	//一直循环判断（判断单链表里还有没有节点,如果有,则头删一次）
	/*while(!IsEmpty(plist))
	{
		Del_head(plist);
	}
	plist->next = NULL;*/

	while (plist->next != NULL)
	{
		struct Node* p = plist->next;
		plist->next = p->next;
		free(p);
	}
	plist->next = NULL;
}

//销毁2
void Destroy2(struct Node* plist)
{
	//assert

	struct Node* p = plist->next;
	struct Node* q = NULL;//q先不要赋值为p->next  因为p有可能指向NULL 

	plist->next = NULL;//接下来 就和我头结点没有任何关系了

	while (p != NULL)
	{
		q = p->next;
		free(p);
		p = q;
	}

}

//打印
void Show(struct Node* plist)
{
	for (struct Node* p = plist->next; p != NULL; p = p->next)
	{
		printf("%d ", p->data);
	}
	printf("\n");
}