单链表的简单使用

#include<stdio.h>
#include <malloc.h>
typedef struct LNode {  //定义节点类型
	int data;   //数据域
	struct LNode* next;    //指针域
}LNode, * LinkList;

//在链表中获得一个元素
LNode* GetElem(LinkList L, int i) {
	int j = 1;
	LNode* p = L->next;
	if (i == 0) {
		return L;
	}
	if (i < 1) {
		return NULL;
	}
	while (p != NULL && j < i) {
		p = p->next;
		j++;
	}
	return p;//返回这个节点
}

//初始化不带头结点的单链表
bool InitList(LinkList &L) {
	L = NULL;   //防止脏数据
	return true;
}
//判断是否为空
bool IsEmpty(LinkList L) {
	return (L == NULL);
}

//初始化带有头结点的单链表
bool InitListHasHead(LinkList& L) {
	L = (LNode*)malloc(sizeof(LNode));//L指向创建的头结点
	if (L == NULL) {
		return false;//分配失败，内存不足
	}
	L->next = NULL;
	return true;
}
//判断是否为空
bool IsEmpty(LinkList L) {
	return (L->next == NULL);
}

//带头结点的按位序插入
bool InsertListHasHead(LinkList& L, int i, int e) {
	if (i < 1) return false;
	LNode* p;   //p指向当前扫描到的节点
	int j = 0;   //当前p指向的是第几个节点,头结点为第0个节点
	p = L;   //L指向头结点
	while (p != NULL && j < i - 1) {
	   //循环找到第i - 1个节点
		p = p->next;
		j++;
	}
	if (p == NULL) return false;
	//新分配一个节点
	LNode* s = (LNode*)malloc(sizeof(LNode));
	s->data = e;//赋值
	s->next = p->next;
	p->next = s;
	return true;
}

//不带头结点的插入
bool InsertListNoHead(LinkList& L, int i, int e) {
	if (i < 1) return false;
	if (i == 1) {
		LNode* s = (LNode*)malloc(sizeof(LNode));
		s->data = e;
		s->next = L;
		L = s;
		return true;
	}
	LNode* p;   //p指向当前扫描到的节点
	int j = 1;   //当前p指向的是第几个节点,头结点为第0个节点
	p = L;   //L指向头结点
	while (p != NULL && j < i - 1) {
		//循环找到第i - 1个节点
		p = p->next;
		j++;
	}
	if (p == NULL) return false;
	//新分配一个节点
	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;
}

//指定节点的前插操作
bool InsertPriorNode1(LNode* p, int e) {
	if (p == NULL) return false;
	LNode* s = (LNode*)malloc(sizeof(LNode));
	if (s == NULL) return false;
	s->next = p->next;
	p->next = s;
	s->data = p->data;  //p的元素复制到s中 
	p->data = e;   //p中元素覆盖为e
	return true;
}
bool InsertPriorNode2(LNode* p, LNode* s) {
	if (p == NULL) return false;
	s->next = p->next;
	p->next = s;
	int temp = p->data;
	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;   //当前p指向的是第几个节点,头结点为第0个节点
	p = L;   //L指向头结点
	while (p != NULL && j < i - 1) {
		//循环找到第i - 1个节点
		p = p->next;
		j++;
	}
	if (p == NULL) return false;
	if (p->next == NULL) return false;
	LNode* q = p->next;   //令q指向被删除的节点
	e = q->data;//存储被删除的元素
	p->next = q->next;
	free(q);
	return true;
}

//删除指定节点
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 true;
}

//按位查找，返回第i个 元素
LNode* GetElem(LinkList L, int i) {
	if (i < 0) return NULL;
	LNode* p;   //指针p指向当前扫描到的节点
	int j = 0;   //当前p指向的是第几个节点
	p = L;   //L指向的是头结点，头结点为0且不存储数据
	while (p != NULL && j < i) {
	   //循环找到第i个节点
		p = p->next;
		j++;
	}
	return p;
}
//按值查找
LNode* LocataElem(LinkList L, int e) {
	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;
}

//尾插法建立单链表，在p节点后插入元素e
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 false;
}
LinkList ListTailInsert(LinkList& L) {
	int x;
	L = (LinkList)malloc(sizeof(LNode));   //创建头结点
	LNode* s, * r = L;   //r为表尾指针
	scanf("%d", &x);
	while (x != 9999) {
		s = (LNode*)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;   //r指向新的节点
		r = s;
	}
	r->next = NULL;
	return L;
}

//头插法建立单链表
LinkList ListHeadInsert(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;   //r指向新的节点
		L->next = s;
		scanf("%d", &x);
	}
	return L;
}

void test() {
	LinkList L;   //生命一个指向单链表的指针，即头指针
	InitList(L);   //初始化一个空表
}