带头结点的单链表的基本操作

#include"iostream"
#include"stdlib.h"
using namespace std;

/*
	此代码为带头结点的链表操作
*/
typedef struct LNode {
	int data;
	struct LNode *next;
}LNode,*LinkList;
//0.初始化链表
void Init(LinkList &L) {
	LNode *p =(LNode *)malloc(sizeof(LNode));	//创建带头结点
	L = p;		
	L->next = NULL;		//头结点初始化
}

//1. 采用头插法建立单链表
bool Insert_head(LinkList &L, int e) {		//e为待插入的元素
	LNode *p = (LNode*)malloc(sizeof(LNode));
		if (!p)			//新结点创建失败
		return false;
	p->data = e;
	p->next = L->next;
	L->next = p;
	return true;
}

//2. 采用尾插法建立单链表		 LNode* &为地址的引用，因为要改变rear指针的值
bool Insert_tail(LinkList &L, int e,LNode*& rear) {		//e为待插入的元素
	LNode *p = (LNode*)malloc(sizeof(LNode));		//rear用于记录最后一个结点
		if (p==NULL)			//新结点创建失败
		 return false;
		p->data = e;
		p->next = rear->next;
		rear->next= p;
		rear = p;
		return true;
}

//3. 按序号查找结点值
LNode* GetElem(LinkList L,int i) {
		if (i < 1)
		return NULL;
		LNode* p = L->next;		//初始化p为第一个结点
		int j = 1;				//计数器，表示当前处于第j个结点
		if (i == 1)
		 return p;
		while (p!=NULL&&j <i) {
			p = p->next;
			j++;
		}
		return p;
}

//4. 按值查找表结点
LNode* LocElem(LinkList L, int e) {
	LNode *p = L->next;			//p指向第一个结点
	while (p!=NULL && p->data != e) { //  地址存在 且 当前结点的值!=e
		p = p->next;
	}			  //找到元素e会返回结点
	return p;	 //找不到元素e，最后会返回链表最后一个结点执向的地方：NULL
}

//5.插入结点操作（前插）
bool Insert_pre(LinkList& L,int i,int e) {	//i表示插入的位置，e为待插入元素
	if (i < 1)
		return false;
	if (i == 1) {		//第一个结点要特殊处理
		LNode* q = (LNode *)malloc(sizeof(LNode));	//q为新建立的结点
		if (q == NULL) return false;
		q->data = e;
		q->next = L->next;
		L->next = q;
		return true;
	}
	LNode* p=GetElem(L, i-1);		//找到第i-1个结点
		if (p==NULL)						//第i个结点不存在
		return false;
	 LNode* q = (LNode *)malloc(sizeof(LNode));	//q为新建立的结点
	 q->data = e;
	 q->next = p->next;
	 p->next = q;
	 return true;
}

//5.2插入结点操作（前插,这是一种逻辑上的插入） 
void Insert_back(LinkList& L, int i, int e) {	//i表示插入的位置，e为待插入元素
	LNode* p = GetElem(L, i);	 //实际上函数传入的i应该为一个指定结点即LNode
	 //为了编写方便我用了GetElem，实际上不应该使用，理解思想最重要
	//假设在p结点之后插入元素e
	if (p == NULL)
		return;
	LNode *q = (LNode*)malloc(sizeof(LNode));	//创建待插入结点
	LNode *tem= (LNode*)malloc(sizeof(LNode));	//用于临时保存p的数据域
	tem->data = p->data;
	//先改数据域
	q->next = p->next;	 
	p->next = q;		//实际上就是在p结点之后插入，只不过待插入的值和p交换了而已，从而达到了前插的目的
	//再改值
	p->data = e;
	q->data = tem->data;
	free(tem);
}

//6.删除结点操作
bool Del_pre(LinkList &L,int i) {	//删除第i个结点
	if (i == 1) {		//对第一个结点特殊处理
		LNode*p = L->next;	//p指向第一个结点
		LNode*q = p->next;	//q指向第二个结点
		L->next = q;
		free(p);
	}
	LNode* p=GetElem(L, i-1);	//找到i-1个结点
		if (p==NULL||p->next==NULL)	 //位序i不合法
		return false;
	LNode* q = p->next;			//第i个结点
	LNode* r = q->next;			//第i+1个结点
	p->next = r;
	free(q);
	return true;
}
 

//7.求表长
int Len(LinkList L) {
	int n = 0;
	LNode* p =(LNode*) malloc(sizeof(LNode));
	p = L;
	while (p->next!=NULL) {
		p = p->next;
		n++;
	}
	return n;
}

//8.打印链表
void Print_LinkList(LinkList L) {
	LNode *p = L->next;			//p初始指向第一个结点
	while (p!=NULL) {				//用p结点去遍历链表
		cout<<p->data<<" ";
		p = p->next;
	}
	cout << endl;
	cout << "当前链表元素个数：" << Len(L) << endl;
}


int main() {
	LinkList L;
	LNode* rear = NULL;
	
	//0.初始化链表
	Init(L);
	Print_LinkList(L); 
	//1.头插法创建链表
	 for (int i = 1; i <= 10; i++) {
		Insert_head(L, i);
	} 
	 Print_LinkList(L);
	//2.尾插法建立链表	
	/* LNode* tail = GetElem(L,10);
	 for (int i = 1; i <= 10; i++) {
		 Insert_tail(L, i,tail);
	 }
	 Print_LinkList(L);*/

	//3. 按序号查找结点值
	LNode* res = GetElem(L, 110);
	if(res!=NULL)
	cout << "3.按序号查找结果为：" << res->data << endl;
	else  cout << "3.按序号查找结果为：NULL"  << endl;
	//4. 按值查找表结点
	res = NULL;
	res=LocElem(L, 1 );
	if (res != NULL)
		cout << "4.按值查找其结点结果为：" << res->data << endl;
	else  cout << "4.按值查找结果为：NULL" << endl;
	//5.插入结点操作（前插）
	Insert_pre(L, 1, 0);
	cout << "5.1插入后结点后：" <<  endl;
	Print_LinkList(L);
	//5.2插入结点操作（前插,这是一种逻辑上的插入） 
	 Insert_back(L,  11, 0);
	cout << "5.2插入后结点后：" << endl;
	Print_LinkList(L);
	//6.删除结点操作
	Del_pre(L, 3 );
	cout << "6.删除结点后：" << endl;
	Print_LinkList(L);


	system("pause");
	return 0;
}