单链表的简单函数定义

单链表的函数定义

#include <stdio.h>
#include <stdlib.h>

#define ElemType int

//判断单链表是否为空
bool Empty(LinkList L) {
		return (L == NULL);
}

//定义单链表结点类型
typedef struct LNode{			
		ElemType data ;				//数据域
		struct LNode *next ;		//指针域
}LNode , *LinkList ;

//初始化一个单链表(带头结点)
bool InitList(LinkList &L) {		
		L = (LNode *)malloc(sizeof(LNode));
		if (L == NULL)
				return false;
	else
				return true;						
}

//查找第i个位置
bool ListSearch(LinkList &L, int i) {
		if (i < 1)
				return false;
		LNode *p;		//指针p指向当前扫描到的结点
		int j = 0;			//当前p指向的是第几个结点
		p = L;				//L指向头结点，头结点是第0个结点（不存数据）
		while (p != NULL && j < i - 1) {		//循环找到第i-1的个结点  —— i-1=0
				p = p->next;
				j++;
		}
}

//在第i个位置插入元素e（带头结点）				——按位序插入
bool ListInsert1(LinkList &L, int i, ElemType 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的个结点  —— i-1=0
				p = p->next;
		j++;
	}
		if (p == NULL)			//i值不合法
				return false;
		LNode *s = (LNode *)malloc(sizeof(LNode));
		s->data = e;	
		s->next = p->next;						//将结点s连到p之后
		p->next = s;									//插入成功
		return true;
}

//后插操作：在p结点之后插入元素e
bool InsertNextNode(LNode *p, ElemType e) {
		if (p == NULL)
				return false;
		LNode *s = (LNode *)malloc(sizeof(LNode));
		if (s == NULL)			//内存分配失败
				return false;
		s->data = e;							//用结点s保存数据元素e
		s->next = p->next;
		p->next = s;							//将结点s连接到p之后
		return true;
}

//前插操作：在p结点之前插入元素e
bool InsertpriorNode(LNode *p, ElemType 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连到p的后面
		s->data = p->data;						//将p的数据复制到s中
		p->data = e;								//p中元素覆盖为e
}

//指定结点的后插		
bool ListInsertNext(LinkList &L, int i, ElemType 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的个结点  —— i-1=0
				p = p->next;
				j++;
		}
		return InsertNextNode(p, e);
}

//指定结点的前插
bool ListInsertPrior(LinkList &L, int i, ElemType 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的个结点  —— i-1=0
				p = p->next;
				j++;
		}
		return InsertpriorNode(p, e);
}

//指定结点的删除
bool DeleteNode(LNode *p) {					//删除指定结点p
		if (p == NULL)
				return false;								//删除失败，无此结点
		LNode *q = p->next;						//令q指向*p的后继结点
		p->data = p->next->data;				//和后继结点交换数据域
		p->next = q->next;							//将*q结点从链中“断开”
		free(q);												//释放后继结点的存储空间
		return true;										//删除成功
		//指定结点是最后一个结点时，需要特殊处理
}

//按位序删除（带头结点）
bool ListDelete(LinkList &L, int i, ElemType &e) {
		if (i < 1)
				return false;
		LNode *p;				//指针p指向当前扫描到的结点
		int j = 0;					//当前p指向的是第几个结点
		p = L;						//p指向头结点，头结点是第0个结点
		while (p != NULL && j < i - 1) {
				p = p->next;
				j++;
		}
		if (p = NULL)				//i值不合法	
				return false;			
		if (p->next = NULL)		//在第i-1个结点之后已无其他结点
				return false;
		LNode *q = p->next;				//令q结点指向被删除结点
		e = q->data;							//用e返回元素的值
		p->next = q->next;					//将*q结点从链中断开
		free(q);										//释放结点的存储空间
		return true;								//删除成功
}