单链表的各种操作

//单链表初始化
//不带头结点
typedef struct LNode{
	int data;
	struct LNode *next;
}LNode,*LinkList;
bool InitList(LinkList &L){   //&是带返回值的符号，传入的引用
	L=NULL;
	return L;
}
int test(){
	LinkList L;   //声明一个单链表指针
	InitList(L);
}
//带头结点
typedef struct LNode{
	int data;
	struct LNode *next;
}LNode,*LinkList;
bool InitList(LinkList &L){    //链表初始化
	L=(LNode *)malloc(sizeof(LNode));   //分配一个头结点
	if(L==NULL){   //内存不足分配失败
		return false;
	}
	L->next=NULL;		//头节点之后暂时没有节点
 	return true;
}
//在第i个位置插入元素e
//单链表插入带头结点
bool ListInsert(LinkList &L,int i,int e){     //i是指将要插入的结点插在i-1和i之间
	if(i<1){
		return false;   //分析 i=1 是将表插在表头	
	}
	LNode *p;
	int j=0;
	p=L;
	while(p!=NULL && j<i-1){      //循环找到i-1个结点
		p=p->next;
		j++;
	}
	if(p==NULL){   //i值不合法
		return false;
	}
	LNode *s=(LNode *)malloc(sizeof(LNode));
	s->data=e;
	s->next=p->next;  //将s前面指针指向的结点，赋值给s指针
	p->next=s;     //原来的p的next指向 s结点
	return true;
}
//单链表不带头结点
bool ListInsert(LinkList &L,int i,int e){     //i是指将要插入的结点插在i-1和i之间
	if(i<1){
		return false;   //分析 i=1 是将表插在表头	
	}
	if(i==1){   //不带头结点要特别注意插入在第一个结点时需要特别强调
		LNode *s=(LNode *) malloc(sizeof(LNode));
		s->data=e;
		s->next=L;
		L=s;   //头指针指向新的结点
		return true;   
	}
	LNode *p;
	int j=1;
	p=L;
	while(p!=NULL && j<i-1){      //循环找到i-1个结点
		p=p->next;
		j++;
	}
	if(p==NULL){   //i值不合法
		return false;
	}
	LNode *s=(LNode *)malloc(sizeof(LNode));
	s->data=e;
	s->next=p->next;  //将s前面指针指向的结点，赋值给s指针
	p->next=s;     //原来的p的next指向 s结点
	return true;
}

//后插操作，在p结点之后插入数据元素e
bool ListNextInsert(LNode *p,int e){
	if(p==NULL){
		return false;
	}
	LNode *s=(LNode *)malloc(sizeof(LNode));
	if(s==NULL){
		return false; //开辟新空间失败
	}
	s->data=e;
	s->next=p->next;
	p->next=s;
	return true;
}
//前插操作，在结点p之前插入元素e
bool ListPriorInsert(LNode *p,int e){
	if(p==NULL){
		return false;
	}
	LNode *s=(LNode *p)malloc(sizeof(LNode));
	if(s==NULL){
		return false;    //内存分配空间失败
	}
	s->next=p->next;	//在p之后后插一个结点
	p->next=s;
	s->data=p->data;    //将p的值给s
	p->data=e;      //再将要插入的e的值给p  这样p和s完成了一个交换 就是前插完成	
	return true;
}
//删除第i个结点（带头指针）
bool ListDelete(LinkList &L,int i,int &e){
	if(i<1){
		return false;
	}
	LNode *p;
	int j=0;
	p=L;
	while(p!=NULL && j<i-1){
		p=p->next;
		j++;
	}
	if(p==NULL){
		return false;
	}
	if(p->next == NULL){   //第i个结点之后无其他结点
		return false;
	}
	LNode *q=p->next;   //q指向被删除的结点
	e=q->data;     //用e返回元素的值
	p->next=q->next;  //将*q结点断开
	free(q);     //释放存储空间
	return true;
}
//删除指定结点p
bool DeleteNode(LNode *p){
	if(p==NULL){
		return false;
	}
	LNode *q=p->next;
	p->data=p->next->data;
	p->next=q->next;
	free(q);
	return false;
}
//按位查找(带头结点)，返回第i个元素（返回第i个指针）
LNode *getElem(LinkList L,int i){
	if(i<0){
		return NULL;
	}
	LNode *p;
	int j=0;
	P=L;
	while(p!=NULL && j<i){
		p=p->next;
		j++;
	}
	return p;
}
//按位查找
LNode *LocateElem(LinkList L,int e){
	//p指向头结点的下一个结点，也就是从第一个结点开始
	LNode *p=L->next;
	while(p!=NULL && p->data!=e){
		p=p->next;
	}
	return p;
}
//求单链表长度
int length(LinkList L){
	int len=0;
	LNode *p = L;
	while(p->next !=NULL){
		p=p->next;
		len++;
	}
	return len;
}
int test(){
	LinkList L;
	InitList(L);
}
*/

//尾插法建立单链表
typedef struct LNode{
	int data;
	struct LNode *next;
}LNode,*LinkList;
//初始化单链表
bool InitList(LinkList &L){
	L=(LNode *)malloc(sizeof(LNode));
	if(L==NULL){
		return false; //内存空间分配失败
	}
	L->next=NULL;
	return true;
}
//尾插法包括了初始化单链表的过程
LinkList List_TailInsert(LinkList &L){
	L=(LinkList)malloc(sizeof(LNode));
	int x;
	LNode *s,*r=L;
	scanf("%d",&x);
	while(x!=9999){
		s=(LNode *)malloc(sizeof(LNode));
		s->data=x;
		r->next=s;
		r=s;
		scanf("%d",&x);
	}
	r->next=NULL;
	return L;
}
//头插法建立单链表
LinkList List_HeadInsert(LinkList &L){
	LNode *s;
	int x;
	L=(LinkList)malloc(sizeof(LNode));
	L->next=NULL;
	scanf("%d",&x);
	while(x!=9999){
		s=(LNode *)malloc(sizeof(LNode));
		s->data=x;
		s->next=L->next;
		L->next=s;
		scanf("%d",&x);
	}
	return L;
}