链表的创建与运算

本节讲述链表的实现

//头文件

#include "iostream"
using namespace std;

typedef int ElemType ;

#define OK 1;
#define TRUE 1;
#define ERROR 0;
#define FALSE 0;


typedef struct LNode{
	ElemType data;
	struct LNode *next;
}*Link,*Position;

typedef struct {
	Link head,tail;
	int len;
}LinkList;

int MakeNode(Link &p,ElemType e);
//分配由p指向的值为e的结点
void FreeNode(Link &p);
//释放p指向的结点

int InitList(LinkList &L);
//构造一个空的链表L
int DestoryList(LinkList &L);
//销毁链表L,L不再存在
int ClearList(LinkList &L);
//将链表置空，并释放原链表的结点空间
int InsFirst(LinkList &L,Link s);
//将s所指结点插入到第一个结点之前（h指向头结点）
Link DelFirst(LinkList &L,Link &q);
//删除链表中的第一个结点并用q返回（h指向头结点）
int Append(LinkList &L,Link s);
//将指针s所指的一串结点链接在链表L的最后一个结点上，并改变L的尾指针指向新的尾结点
Link Remove (LinkList &L,Link &q);
//删除链表L的尾结点并以q返回，改变L的尾指针指向新的尾结点
int InsBefore(LinkList &L,Link &p,Link s);
//p指向链表L中的一个结点，将s所指向的结点插入到p所指结点的前面
//并修改指针p指向新插入的结点
int InsAfter(LinkList &L,Link &p,Link s);
//p指向链表L中的一个结点，将s所指向的结点插入到p所指结点的后面
//并修改指针p指向新插入的结点

int is_In(LinkList &L,Link p);
//判断p所指向的结点是否在链表L中

int SetCurElem(Link &p,ElemType e);
//p指向链表L中的一个结点，用e更新p所指结点中数据元素的值
ElemType GetElem(Link p);
//p指向链表L中的一个结点，返回p所指结点中数据元素的值
int ListEmpty (LinkList L);
//链表L是否为空
int ListLength(LinkList L);
//返回链表中元素个数
Position GetHead(LinkList L);
//返回链表L的头结点位置
Position GetLast(LinkList L);
//返链表L的最后一个结点的位回置
Position PriorPos (LinkList L,Link p);
//p指向链表L中的一个结点，返回p所指结点的前驱位置，若无前驱，则返回NULL
Position NextPos (LinkList L,Link p);
//p指向链表L中的一个结点，返回p所指结点的后继位置，若无后继，则返回NULL
int LocatePos (LinkList L,int i,Link &p);
//用p返回链表中第i个结点
Position LocateElem (LinkList L,ElemType e,int (*compare)(ElemType,ElemType));
//返回链表L中的第一个与e 满足compare（）判定关系的元素的位置，若不存在，则返回NULL
int ListTraverse(LinkList L,int (*visit)(Link));
//依次对L中的每个元素调用visit（）
int visit(Link);

int equals(ElemType e1,ElemType e2);
int less_than(ElemType e1,ElemType e2);
int more_than(ElemType e1,ElemType e2);

源文件

// ListNode.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include "ListNode_h.h"

int MakeNode(Link &p,ElemType e){
	p = (LNode*)malloc(sizeof (LNode));
	if (!p){
		exit(OVERFLOW);
	}
	p->data = e;
	p->next = NULL;
	return OK;
}

void FreeNode(Link &p){
	free(p);
}

int InitList(LinkList &L){
	Link p;
	p = (LNode*)malloc (sizeof (LNode));
	if (!p){
		exit(OVERFLOW);
	}
	p->data =NULL;
	p->next = NULL;
	L.head = p;
	L.tail = p;
	L.len = NULL;
	return OK;
}

int DestoryList(LinkList &L){
	Link p = L.head;
	Link q = L.head->next;
	while (q!=NULL){
		p->next = q->next;
		free(q);
	}
	free(L.head);
	free(L.tail);
	return OK;
}

int ClearList(LinkList &L){
	Link p = L.head;
	Link q = L.head->next;
	while (q!=NULL){
		p->next = q->next;
		free(q);
	}
	return OK;
}

int InsFirst(LinkList &L,Link s){
	Link h = L.head;
	if (h->next == NULL){
		h->next = s;
		s->next = NULL;
	}
	else
	{
		s->next = h->next;
		h->next = s;
	}
	L.len++;
	return OK;
}

Link DelFirst(LinkList &L,Link &q){
	L.len--;
	Link h = L.head;
	Link p = h->next;
	if (h->next == NULL)
		return NULL;
	else if (p->next == NULL){
		q = p;
		q->next = NULL;
		h->next = NULL;
		L.tail = h;
		return q;
	}
	else{
		q = h->next;
		
		h->next = p->next;
		q->next = NULL;
		return q;
	} 

}

int Append(LinkList &L,Link s){
	int i = 1;
	if (L.head->next == NULL){
		L.head->next = s;
		L.tail = s;
	}
	else{
		L.tail->next = s;
		L.tail = L.tail->next;
	}

	while (s->next!=NULL){
		L.tail = s->next;
		s = s->next;
		i++;
	}
	L.len += i;
	return OK;
}

int ListEmpty (LinkList L){
	if (L.head->next==NULL&&L.tail->next==NULL){
		return TRUE;
	}
	//if ((L.head!=NULL)&&(L.tail!=NULL)) 
	else{
		return FALSE;
	}
}

Link Remove (LinkList &L,Link &q){
	Link p = L.head->next;
	if (ListEmpty(L)){
		return FALSE;
	}
	else{
		while (p->next!=L.tail)
			p = p->next;
		q = L.tail;
		p ->next = NULL;
		L.tail = p;
		L.len--;
		return q;
	}
}

int InsBefore(LinkList &L,Link &p,Link s){
	Link q = L.head;
	while (q->next != p)
		q = q->next;
	s->next = p;
	q->next = s;
	return OK;
}

int InsAfter(LinkList &L,Link &p,Link s){
	if (p->next == NULL){
		p->next = s;
		L.tail = s;
	}
	else{
		s->next = p->next;
		p->next = s;
	}
	return OK;
}

int is_In(LinkList &L,Link p){
	Link q = L.head ->next;
	while((q != p) &&(q != NULL)){
		q = q->next;
	}
	if (q != NULL){
		return TRUE;}
	else {
		return FALSE;}
}

int SetCurElem(Link &p,ElemType e){
	p->data = e;
	return OK;
}

ElemType GetElem(Link p){
	return p->data;
}

int ListLength(LinkList L){
	return L.len;
}

Position GetHead(LinkList L){
	return L.head;
}

int LocatePos (LinkList L,int i,Link &p){
	int j = 1;
	Link q = L.head ->next;
	if (i<=0||i>L.len){
		return ERROR;
	}
	else {
		while (j != i){
			q = q -> next;
			j++;
		}
		p = q;
	}
	return OK;
}

Position LocateElem(LinkList L,ElemType e,int (*compare)(ElemType,ElemType)){
	Link p = L.head ->next;
	while ((!compare(p->data,e))&&(p->next!=NULL)){
		p = p->next;
	}
	if (p->next!=NULL){
		return p;
	}
	else{
		return NULL;
	}
}

int equals(ElemType e1,ElemType e2){
	if (e1==e2){
		return OK;
	}
	else{
		return FALSE;
	}
}

int less_than(ElemType e1,ElemType e2){
	if (e1<=e2){
		return OK;
	}
	else{
		return FALSE;
	}
}

int more_than(ElemType e1,ElemType e2){
	if (e1>=e2){
		return OK;
	}
	else{
		return FALSE;
	}
}

int ListTraverse(LinkList L,int (*visit)(Link)){
	Link p = L.head->next;
	while (p!=NULL){
		visit(p);
		p = p->next;
	}
	cout<<endl;
	return OK;
}

int visit(Link p){
	cout<<p->data<<" ";
	return OK;
}