【数据结构】带头结点的单链表

【数据结构】带头结点的单链表

链表：逻辑连续，物理上不一定连续

带头结点的单链表：

结构体：

//定义结构体
typedef int ELEM_TYPE;
typedef struct Node
{
	ELEM_TYPE mdata;
	struct Node* pnext;
}Node,*Link;

尾插：

//给尾部插入
bool InsertTail(Link phead , ELEM_TYPE val)
{
	if(phead == NULL)
	{
		return false;
	}
	struct Node* pCur = phead;
	while(pCur -> pnext != NULL)
	{
		pCur =pCur->pnext ;
	}//找到最后一个节点
	struct Node* pnewnode = BuyNode();
	pCur ->pnext =pnewnode ;
	pnewnode ->mdata=val ;
	return true;
}

头插：

//给头部插入
bool InsertHead(Link phead,ELEM_TYPE val)
{
	if(phead == NULL)
	{
		return false;
	}
	struct Node* pnewnode=BuyNode();
	pnewnode->mdata = val;
	//注意：连接的时候先连后面，再连前面，防止死循环
	pnewnode ->pnext =phead->pnext ;
	phead->pnext =pnewnode ;
	return true;
}

开辟新节点：

//开辟新节点
Link BuyNode( )
{
	struct Node* pnewnode = (struct Node*)malloc(sizeof(struct Node));
	assert(pnewnode !=NULL);
	pnewnode ->pnext =NULL;
}

按元素删除：

//按元素删除
bool Deletekey(Link phead,ELEM_TYPE val)
{
	if(phead == NULL)
	{
		return false;
	}
	struct Node* pfront = phead;
	while(pfront ->pnext != NULL)
	{
		//找得到
		if(pfront->pnext ->mdata == val)
		{
			break;
		}
		pfront = pfront ->pnext ;
	}
	//没找到
	if(pfront ->pnext == NULL)
	{
		return false;
	}
	Node *pCur = pfront->pnext ;
	pfront->pnext = pCur ->pnext ;
	free(pCur );
	return true;
}

单链表的逆置：

方法：多次头插

//单链表的逆置
void Reverse(Link phead)
{
	if(phead == NULL)
	{
		return ;
	}
	Node* pCur = phead ->pnext ;
	Node* pNext = pCur;
	phead->pnext = NULL;
	while(pCur != NULL)
	{
		pNext = pCur->pnext ;
		pCur ->pnext = phead->pnext ;//头插
		phead ->pnext =pCur;
		pCur = pNext;
	}
}

清除数据节点：

//清除数据节点
//方法：设两个指针，指向当前节点和下一个节点，以便保存
void Clear(Link phead)
{
	struct Node* pCur = phead->pnext;
	struct Node* pNext = pCur ;
	while(pCur != NULL)
	{
		pNext = pCur ->pnext ;//删除数据节点，向后移动
		free(pCur );//释放
		pCur = pNext;//向后移动
	}
	phead->pnext =NULL;//删除头，否则将成为野指针
}

代码汇总：

Link.cpp

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include"Link.h"
//带头结点的单链表


//初始化
void Init(Link phead)
{
	if(phead==0)
	{
		return ;
	}
	assert(phead!=NULL);
	phead->pnext=NULL;
}

//开辟新节点
Link BuyNode( )
{
	struct Node* pnewnode = (struct Node*)malloc(sizeof(struct Node));
	assert(pnewnode !=NULL);
	pnewnode ->pnext =NULL;
	return pnewnode ;
}

//给尾部插入
bool InsertTail(Link phead , ELEM_TYPE val)
{
	if(phead == NULL)
	{
		return false;
	}
	struct Node* pCur = phead;
	while(pCur -> pnext != NULL)
	{
		pCur =pCur->pnext ;
	}//找到最后一个节点
	struct Node* pnewnode = BuyNode();
	pCur ->pnext =pnewnode ;
	pnewnode ->mdata=val ;
	return true;
}

//给头部插入
bool InsertHead(Link phead,ELEM_TYPE val)
{
	if(phead == NULL)
	{
		return false;
	}
	struct Node* pnewnode=BuyNode();
	pnewnode->mdata = val;
	//注意：连接的时候先连后面，再连前面，防止死循环
	pnewnode ->pnext =phead->pnext ;
	phead->pnext =pnewnode ;
	return true;
}

//打印
void Print(Link phead)
{
	if(phead == NULL)
	{
		return ;
	}
	struct Node* pCur = phead->pnext ;
	while(pCur != NULL)
	{
		printf ("%d  ",pCur ->mdata );
		pCur =pCur ->pnext;
	}
}


//按元素删除
bool Deletekey(Link phead,ELEM_TYPE val)
{
	if(phead == NULL)
	{
		return false;
	}
	struct Node* pfront = phead;
	while(pfront ->pnext != NULL)
	{
		//找得到
		if(pfront->pnext ->mdata == val)
		{
			break;
		}
		pfront = pfront ->pnext ;
	}
	//没找到
	if(pfront ->pnext == NULL)
	{
		return false;
	}
	Node *pCur = pfront->pnext ;
	pfront->pnext = pCur ->pnext ;
	free(pCur );
	return true;
}

//单链表的逆置
void Reverse(Link phead)
{
	if(phead == NULL)
	{
		return ;
	}
	Node* pCur = phead ->pnext ;
	Node* pNext = pCur;
	phead->pnext = NULL;
	while(pCur != NULL)
	{
		pNext = pCur->pnext ;
		pCur ->pnext = phead->pnext ;//头插
		phead ->pnext =pCur;
		pCur = pNext;
	}
}

//清除数据节点
//方法：设两个指针，指向当前节点和下一个节点，以便保存
void Clear(Link phead)
{
	struct Node* pCur = phead->pnext;
	struct Node* pNext = pCur ;
	while(pCur != NULL)
	{
		pNext = pCur ->pnext ;//删除数据节点，向后移动
		free(pCur );//释放
		pCur = pNext;//向后移动
	}
	phead->pnext =NULL;//删除头，否则将成为野指针
}

Link.h

#include<assert.h>
//定义结构体
typedef int ELEM_TYPE;
typedef struct Node
{
	ELEM_TYPE mdata;
	struct Node* pnext;
}Node,*Link;

//初始化
void Init(Link phead);

//给尾部插入
bool InsertTail(Link phead , ELEM_TYPE val);

//给头部插入
bool InsertHead(Link phead,ELEM_TYPE val);

//开辟新节点
Link BuyNode();

//打印
void Print(Link phead);

//按元素删除
bool Deletekey(Link phead,ELEM_TYPE val);

//单链表的逆置
void Reverse(Link phead);

//清除数据节点
void Clear(Link phead);