C语言实现单链表_*p=l

/*
* @Author: zyx
* @Date:   2020-11-01 22:22:22
* @Last Modified by:   zyx
* @Last Modified time: 2020-11-02 17:57:58
* @title: 单链表（LinkList）
*/
 
#include <stdio.h>
#include <stdlib.h>
typedef struct LNode // 定义单链表结点类型
{
	int data;	// 每个结点存放一个数据元素
	struct LNode *next; // 指针指向下一节点
}LNode,*LinkList; 
 
// LNode *L; // 声明一个指向单链表第一个结点的指针
// LinkList L; // 声明一个指向单链表第一个结点的指针
// 这两个效果等价，这种命名方式增加可读性
// LNode 强调结点， 而LinkList强调单链表， 
// 返回值是LNode *强调返回单链表的一个结点
// 返回值是LinkList 强调返回一个单链表
 
// 初始化一个单链表(无头结点)
// bool InitList(LinkList L){ // 注意L是指针类型
// 	L = NULL; // 空表，暂时无任何数据
// 	return true;
// }
bool InitList(LinkList L){
	// 生成新节点作为头结点，用头指针L指向头结点
	L = (LNode *)malloc(sizeof(LNode));
	if(L==NULL) return false;
	L->next = NULL; // 头结点的指针域置空
	return true;
}
 
bool ListInsert(LinkList L,int i,int e){
    // 注意前提是头结点存在
	if(i<1) return false;
	LNode *p; // 指针p指向扫描到的结点
	int j = 0; //当前p指向的是第几个结点
	p = L; // L指向头结点，头结点是第0个结点（不存在数据）
	while(p!=NULL && j<i-1){// 扫描到第i-1个元素且当前节点不为空
		p = p->next;
		j++
	}
	if(p==NULL) return false; // i值不合法
	LNode *s = (LNode *)malloc(sizeof(LNode)); // 为新节点申请空间
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}
bool InsertNextNode(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前插入节点s ,
bool InsertPriorNode(LNode *p,LNode *s){
	if(p==NULL||s==NULL) return false;// 1.验证有效
	s->next = p->next; // 2. 先进行后插
	p->next = s; 
	int temp = p->data; // 3. 将p结点数据与s结点数据交换
	p->data = s->data;
	s->data = temp;
	return true
}
// 按位序删除(带头结点)
bool ListDelete(LinkList L,int i,int *e){
	if (i<1) return false;
	LNode *p; // 指针p扫描到当前节点
	int j = 0; // j表示到第几个结点
	P = L;
	// 找到要删除结点的前驱结点
	while(p!=NULL && j<i-1){
		p = p->next;
		j++;
	}
	if(p==NULL) return false;
	// 将前驱结点与后继结点连接
	LNode *q = p->next; //令q指向被删除结点
	*e = q->data; // e返回删除的值
	p->next = q->next; // 将前驱结点与后继结点相连
	free(q); // 释放删除结点内存
	return true; 
}
// 删除指定节点p
bool DeleteNode(LNode *p){
	if(p==NULL) return false;
	LNode *q = p->next; // 用q指向后继结点
	if(q==NULL){//如果p是尾结点，那么p->next==NULL
		p = NULL;
		return true;
	}
	p->data = p->next->data; // 和后继节点交换数据
	p->next = q->next; // 将后继结点从链表中剔除
	free(q); // 释放后继结点的存储空间;
	return true;
}
// 按位查找，返回第i个元素(带头结点)
LNode *GetElem(LinkList L,int i){
	if(i<0) return NULL;
	LNode *p;
	j = 0;
	p = L;
	while(p!=NULL && j<i-1){
		p = p->next;
		j++;
	}
	return p;
}
// 按值查找，找到数据域==e的结点
LNode *LocateElem(LinkList L,int e){
	LNode *p = L;
	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;
}
// 尾插法建立单链表,正向建立单链表
LinkList ListTailInsert(LinkList L){
	int x;// 新节点的数据
	L = (LinkList)malloc(sizeof(LNode));//建立头结点 初始化空表
	L->next = NULL;
	// LNode *s,*t = L;//s表示新的结点，t表示尾结点
	LNode *s;
	LNode *t = L;
	scanf("%d",&x);
	while(x!=-1){
		s = (LNode *)malloc(sizeof(LNode));// 为新节点分配空间
		t->next = s;
		s->data = x;
		t = s;
		scanf("%d",&x);
	}
	t->next = NULL; //尾结点置空
	return L;
}
//头插法
LinkList ListHeadInsert(LinkList L){
	int x;
	LNode *s;
	L = (LinkList)malloc(sizeof(LNode));
	L->next = NULL;
	scanf("%d",&x);
	while(x!=-1){
		s = (LNode *)malloc(sizeof(LNode));//为新节点分配空间
		s->data = x;
		s->next = L->next;
		L->next = s;
		scanf("%d",&x);
	}
	return L;
}
// 逆序单链表(带头结点)
LinkList ListReverse(LinkList L){
	// 1. 空链表，或者只有头结点的链表
	if(L==NULL||L->next==NULL) return NULL;
	// 2. 按顺序将所有剩下的结点对【头结点的后一个结点L->next】进行头插
	// 直到剩余结点为空
	LNode *s = L->next;// 当前头结点的下一节点，之后的标志,不变
	LNode *r = s->next; // 当前待头插的结点，一直成为L->next
	while(s->next!=NULL){
		s->next = r->next; // H->A->B->C->D变成H->A->C->D,B
		r->next = L->next; // 再变成H->B->A->C->D
		L->next = r;
		// 下次循环H-B-A-C-D变成H-B-A-D,C
		// 再变成H-C-B-A-D
	}
	return L;
}
int main() {
 
    return 0;
}