数据结构第二章--线性表链表

转自：http://blog.csdn.net/ggxxkkll/article/details/8661032

线性表的链接存储结构---单链表

图解：









LinkList.h文件

[cpp] view
plaincopy

//LinkList.h 声明类LinkList

#ifndef LinkList_H

#define LinkList_H

template <class T>

struct Node

{

T data;

Node<T> *next; //此处<T>也可以省略

};

template <class T>

class LinkList

{

public:

LinkList( ); //建立只有头结点的空链表

LinkList(T a[ ], int n); //建立有n个元素的单链表

~LinkList(); //析构函数

int Length(); //求单链表的长度

T Get(int i); //取单链表中第i个结点的元素值

int Locate(T x); //求单链表中值为x的元素序号

void Insert(int i, T x); //在单链表中第i个位置插入元素值为x的结点

T Delete(int i); //在单链表中删除第i个结点

void PrintList( ); //遍历单链表，按序号依次输出各元素

private:

Node<T> *first; //单链表的头指针

};

#endif

LinkList.cpp文件

[cpp] view
plaincopy

//LinkList.cpp

#include "LinkList.h"

/*

*前置条件：单链表不存在

*输 入：无

*功 能：构建一个单链表

*输 出：无

*后置条件：构建一个单链表

*/

template <class T>

LinkList<T>:: LinkList( )

{

first=new Node<T>; first->next=NULL;

}

/*

*前置条件：单链表不存在

*输 入：顺序表信息的数组形式a[],单链表长度n

*功 能：将数组a[]中元素建为长度为n的单链表

*输 出：无

*后置条件：构建一个单链表

*/

template <class T>

LinkList<T>:: LinkList(T a[ ], int n)

{

first=new Node<T>; //生成头结点

Node<T> *r,*s;

r=first; //尾指针初始化

for (int i=0; i<n; i++)

{

s=new Node<T>; s->data=a[i]; //为每个数组元素建立一个结点

r->next=s; r=s; //插入到终端结点之后

}

r->next=NULL; //单链表建立完毕，将终端结点的指针域置空

}

/*

*前置条件：无

*输 入：无

*功 能：无

*输 出：无

*后置条件：无

*/

template <class T>

LinkList<T>:: ~LinkList()

{

}

/*

*前置条件：单链表存在

*输 入：查询元素位置i

*功 能：按位查找位置为i的元素并输出值

*输 出：查询元素的值

*后置条件：单链表不变

*/

template <class T>

T LinkList<T>::Get(int i)

{

Node<T> *p; int j;

p=first->next; j=1; //或p=first; j=0;

while (p && j<i)

{

p=p->next; //工作指针p后移

j++;

}

if (!p) throw "位置";

else return p->data;

}

/*

*前置条件：单链表存在

*输 入：查询元素值x

*功 能：按值查找值的元素并输出位置

*输 出：查询元素的位置

*后置条件：单链表不变

*/

template <class T>

int LinkList<T>::Locate(T x)

{

Node<T> *p; int j;

p=first->next; j=1;

if(p&&p->next){

while(p->data!=x)

{

p=p->next;

j++;

}

return j;

}

else throw "位置";

}

/*

*前置条件：单链表存在

*输 入：插入元素x,插入位置i

*功 能：将元素x插入到单链表中位置i处

*输 出：无

*后置条件：单链表插入新元素

*/

template <class T>

void LinkList<T>::Insert(int i, T x)

{

Node<T> *p; int j;

p=first ; j=0; //工作指针p初始化

while (p && j<i-1)

{

p=p->next; //工作指针p后移

j++;

}

if (!p) throw "位置";

else {

Node<T> *s;

s=new Node<T>;

s->data=x; //向内存申请一个结点s，其数据域为x

s->next=p->next; //将结点s插入到结点p之后

p->next=s;

}

}

/*

*前置条件：单链表存在

*输 入：无

*功 能：输出单链表长度

*输 出：单链表长度

*后置条件：单链表不变

*/

template <class T>

int LinkList<T>::Length( )

{

Node <T> *p = first->next;

int i = 0;

while(p)

{

p = p->next;

i++;

}

return i;

}

/*

*前置条件：单链表存在

*输 入：要删除元素位置i

*功 能：删除单链表中位置为i的元素

*输 出：无

*后置条件：单链表删除元素

*/

template <class T>

T LinkList<T>::Delete(int i)

{

Node<T> *p; int j;

p=first ; j=0; //工作指针p初始化

while (p && j<i-1) //查找第i-1个结点

{

p=p->next;

j++;

}

if (!p || !p->next) throw "位置"; //结点p不存在或结点p的后继结点不存在

else {

Node<T> *q; int x;

q=p->next; x=q->data; //暂存被删结点

p->next=q->next; //摘链

delete q;

return x;

}

}

/*

*前置条件：单链表存在

*输 入：无

*功 能：单链表遍历

*输 出：输出所有元素

*后置条件：单链表不变

*/

template <class T>

void LinkList<T>::PrintList( )

{

Node<T> *p;

p=first->next;

while (p)

{

cout<<p->data<<endl;

p=p->next;

}

}

"Common.h"

[cpp] view
plaincopy

#ifndef COMMON_H_INCLUDED

#define COMMON_H_INCLUDED

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <stdarg.h>

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

#define OVERFLOW -2

typedef int Status;

typedef int ElemType;

#endif // COMMON_H_INCLUDED

"List_Linked.h"

[cpp] view
plaincopy

#ifndef LIST_LINKED_H_INCLUDED

#define LIST_LINKED_H_INCLUDED

#include "Common.h"

typedef struct LNode {//结点类型

ElemType data;

struct LNode * next;

} Link, * Position;

typedef struct {//链表类型

Link * head;

Link * tail;

int len;

} LinkList;

Status MakeNode_Linked(Link * p, ElemType e);

void FreeNode_Linked(Link * p);

Status InitList_Linked(LinkList * l);

Status DestroyList_Linked(LinkList * l);

Status ClearList_Linked(LinkList * l);

Status InsFirst_Linked(LinkList * l, Link * s);//h为头结点，s为所指结点，s插入到第一个结点前

Status DelFirst_Linked(LinkList * l, Link * q);

Status Append_Linked(LinkList * l, Link * s);//将s所指一串结点链接在list的最后一个结点并修改list尾指针

Status Remove_Linked(LinkList * l, Link * q);//删除尾结点，以q返回，改变list尾指针

Status InsBefore_Linked(LinkList * l, Link * p, Link * s);//在p指向的结点前插入结点s，修改指针p指向新插入的结点

Status InsAfter_Linked(LinkList * l, Link * p, Link * s);

Status SetCurElem_Linked(Link * p, ElemType e);//用e更新p的值

ElemType GetCurElem_Linked(Link p);

Status ListEmpty_Linked(LinkList * l);

int ListLength_Linked(LinkList * l);

Position GetHead_Linked(LinkList * l);

Position GetLast_Linked(LinkList * l);

Position PriorPos_Linked(LinkList * l, Link * p);//返回p的前驱

Position NextPos_Linked(LinkList * l, Link * p);

Status LocatePos_Linked(LinkList * l, int i, Link * p);//p返回list中第i个结点的位置

Position LocateElem_Linked(LinkList * l, ElemType e);//返回list中与e相等的元素的位置

Status ListTraverse_Linked(LinkList * l);

#endif // LIST_LINKED_H_INCLUDED

"List_Linked.c"

[cpp] view
plaincopy

#include "List_Linked.h"

Status MakeNode_Linked(Link * p, ElemType e)

{

p->data = e;

p->next = NULL;

return OK;

}

void FreeNode_Linked(Link * p)

{

free(p);

}

Status InitList_Linked(LinkList * l)

{

l->head = (Link *)malloc(sizeof(Link));

l->tail = (Link *)malloc(sizeof(Link));

if(!l->head || !l->tail)

exit(OVERFLOW);

l->len = 0;

l->head = l->tail;

l->tail->next = NULL;

return OK;

}

Status DestroyList_Linked(LinkList * l)

{

ClearList_Linked(l);

free(l->head);

l->tail = NULL;

l->len = 0;

l = NULL;

return OK;

}

Status ClearList_Linked(LinkList * l)

{

Link * temp;

Link * temp2;

if(l->head != l->tail)

{

temp = l->head->next;

l->head->next = NULL;

l->len = 0;

while(temp != l->tail)

{

temp2 = temp->next;

free(temp);

temp = temp2;

}

free(temp);

l->tail = l->head;

}

return OK;

}

Status InsFirst_Linked(LinkList * l, Link * s)//h为头结点，s为所指结点，s插入到第一个结点前

{

Link * h = l->head;

if(h != l->tail)

{

s->next = h->next;

}

else

{

s->next = NULL;

l->tail = s;

}

h->next = s;

l->len++;

return OK;

}

Status DelFirst_Linked(LinkList * l, Link * q)

{

if(l->head != l->tail)

{

q = l->head->next;

if(!q->next)

{

l->tail = l->head;

}

else

{

l->head->next = q->next;

}

l->len--;

return OK;

}

else

{

return ERROR;

}

}

Status Append_Linked(LinkList * l, Link * s)//将s所指一串结点链接在list的最后一个结点并修改list尾指针

{

Link * temp = l->tail;

temp->next = s;

int i = 1;

while(temp->next)

{

temp = temp->next;

i++;

}

l->len += i;

l->tail = temp;

return OK;

}

Status Remove_Linked(LinkList * l, Link * q)//删除尾结点，以q返回，改变list尾指针

{

Link * temp = l->head;

while(temp->next->next)

{

temp = temp->next;

}

*q = *temp->next;

l->tail = temp;

l->tail->next = NULL;

printf("%d ", q->data);

return OK;

}

Status InsBefore_Linked(LinkList * l, Link * p, Link * s)//在p指向的结点前插入结点s，修改指针p指向新插入的结点

{

Link * temp = l->head;

while(temp->next && temp->next != p)

{

temp = temp->next;

}

s->next = p;

temp->next = s;

l->len++;

return OK;

}

Status InsAfter_Linked(LinkList * l, Link * p, Link * s)

{

s->next = p->next;

p->next = s;

if(p == l->tail)

{

l->tail = s;

}

l->len++;

return OK;

}

Status SetCurElem_Linked(Link * p, ElemType e)//用e更新p的值

{

p->data = e;

return OK;

}

ElemType GetCurElem_Linked(Link p)

{

return p.data;

}

Status ListEmpty_Linked(LinkList * l)

{

if(l->head == l->tail)

return TRUE;

else

return FALSE;

}

int ListLength_Linked(LinkList * l)

{

return l->len;

}

Position GetHead_Linked(LinkList * l)

{

return l->head;

}

Position GetLast_Linked(LinkList * l)

{

return l->tail;

}

Position PriorPos_Linked(LinkList * l, Link * p)//返回p的前驱

{

Link * temp = l->head;

while(temp && temp->next!=p)

temp = temp->next;

return temp;

}

Position NextPos_Linked(LinkList * l, Link * p)

{

return p->next;

}

Status LocatePos_Linked(LinkList * l, int i, Link * p)//p返回list中第i个结点的位置

{

if(i<1 || i>ListLength_Linked(l))

{

return ERROR;

}

int j;

Link * temp = l->head;

for(j=0; j<i; j++)

{

temp = temp->next;

}

*p = *temp;

return OK;

}

Position LocateElem_Linked(LinkList * l, ElemType e)//返回list中与e相等的元素的位置

{

Link * temp = l->head;

while(temp)

{

if(temp->data == e)

return temp;

temp = temp->next;

}

return NULL;

}

Status ListTraverse_Linked(LinkList * l)

{

if(l->len != 0)

{

Link * temp = l->head->next;

while(temp)

{

printf("%d ", temp->data);

temp = temp->next;

}

}

return OK;

}