数据结构--线性链表（完整）

// Completed Linked List.cpp : Defines the entry point for the console application.
/*-----CODE FOR FUN---------------
-------CREATED BY Dream_Whui--
-------2015-1-26-------------------*/

#include "stdafx.h"
#include <cstdlib>
#include <iostream>
using namespace std;

#define   TRUE                    1
#define   FALSE                    0
#define   OK                        1
#define   ERROR                0
#define   OVERFLOW       -2
#define   INFEASIBLE           -1

#define ElemType char     //定义链表中元素的类型

typedef struct LNode    //结点的结构
{
    ElemType data;
    LNode *next;
}*Link,*Position;

typedef struct LinkList   //定义链表的结构
{
    Link head;
    Link tail;
    int len;
}LinkList;

int MakeNode(Link &p, ElemType e)//分配有p指向的值为e的结点，并返回OK,否则返回ERROR
{
    p = (Link)malloc(sizeof(ElemType));
    if(!p)
        return ERROR;
    p->data = e;
    return OK;
}

void FreeNode(Link &p)//释放p指向的结点
{
    free(p);
    p = NULL;
}

int InitList(LinkList &L)//链表初始化
{
    Link p = (Link)malloc(sizeof(LNode));
    if(!p)
        return ERROR;
    p->next = NULL;
    L.head = L.tail = p;
    L.len =0;
    return OK;
}

void ClearList(LinkList &L)//将线性链表置为空表，并释放原链表结点空间
{
    Link p,q;
    if(L.head != L.tail)
    {
        p = q = L.head->next;
        L.head->next =NULL;
        while(p != L.tail)
        {
            q = p->next;
            free(p);
            p = q;
        }
        free(p);
        L.tail = L.head;
        L.len = 0;
    }
}

void DestroyList(LinkList &L)//销毁线性链表
{
    ClearList(L);
    FreeNode(L.head);
    L.tail = NULL;
    L.len = 0;
}

void InsFirst(LinkList &L, Link h, Link &s)//h指向线性链表的头结点，在h之后插入s指向的结点
{
    s->next = h->next;
    h->next = s;
    if(h == L.tail)
        L.tail = s;
    L.len++;
}

int DelFirst(LinkList &L, Link h, Link &q)//h指向线性链表的头结点，删除h之后的第一个结点，并以q返回
{
    q = h->next;
    if(q)
    {
        h->next = q->next;
        if(q == L.tail)
            L.tail = h;
        L.len--;
        return OK;
    }
    else
        return ERROR;
}

int Append(LinkList &L, Link s)//将s指向的链表一串结点链接在L的尾结点后，并将尾结点指向新的尾结点
{
    Link p = s;
    int   j = 1;
    if(!p)
        return ERROR;
    L.tail->next = s;
    while(p->next)
    {
        p = p->next;
        j++;
    }
    L.tail = p;
    L.len += j;
    return OK;
}

int Remove(LinkList &L, Link &q)//删除L的尾结点，并以q返回，改变链表的尾指针指向新的尾结点
{
    if(L.len == 0)
    {
        q = NULL;
        return ERROR;
    }
    Link p = L.head;
    while(p->next != L.tail)
    {
        p = p->next;
    }
    q = L.tail;
    p->next = NULL;
    L.tail = p;
    L.len--;
    return OK;
}

void InsBefore(LinkList &L, Link &p, Link s)//p为链表L中的一个结点，在p之前插入s指向的结点，并使p指向新的结点
{
    Link temp = L.head;
    while(temp->next != p)
        temp = temp->next;
    s->next = temp->next;
    temp->next = s;
    L.len++;
    p = s;
}

void InsAfter(LinkList &L, Link &p, Link s)//p是链表L中的一个结点，在p之后插入s指向的结点，并使p指向新的结点
{
    if(p == L.tail)
    {
        p->next = s;
        s->next = NULL;
        L.tail = s;
    }
    else
    {
        s->next = p->next;
        p->next = s;
    }
    p = s;
    L.len++;
}

void SetCurElem(Link &p , ElemType e)//用e更新p指向结点的元素
{
    p->data = e;
}

ElemType GetCurElem(Link p)//获取p指向的结点中数据元素的值
{
    return p->data;
}

int ListEmpty(LinkList &L)//链表是否为空
{
    return L.len == 0 ? 1:0;
}

int ListLength(LinkList &L)//链表的长度
{
    return L.len;
}

Position GetHead(LinkList L)//获取链表的头结点
{
    return L.head;
}

Position GetLast(LinkList L)//获取链表的尾结点
{
    return L.tail;
}

Position PriorPos(LinkList L, Link p)//p为线性链表L的结点，返回p指向的结点的直接前驱，反则返回NULL
{
    if(p || p==L.head || p==L.head->next)
        return NULL;
    Link temp = L.head;
    while(temp->next != p)
    {
        temp = temp->next;
    }
    return temp;
}

Position NextPos(LinkList L, Link p)//p为线性链表L的结点，返回p指向的结点的直接后继，反则返回NULL
{
    if(p)
        return NULL;
    return p->next;
}
int LocatePos(LinkList L, int i ,Link &p)//返回线性链表L中第i个结点，并以p返回
{
    int j=0;
    p = L.head;
    while(p && j<i)
    {
        p = p->next;
        j++;
    }
    if( j>i || !p)
        return ERROR;
    return OK;
}

int cmp(ElemType a, ElemType b)//结点数据值a>b 返回1 ， a<b 返回-1 ， a=b返回0
{
    if(a>b)
        return 1;
    else if(a<b)
        return -1;
    else
        return 0;
}

Position LocateElm(LinkList L, ElemType e, int (*cmp)(ElemType,ElemType))//返回线性链表L中第一个满足cmp条件的结点
{
    Link p = L.head->next;
    while(p && !cmp(e,p->data))
        p= p->next;
    return p;
}

void Visit(ElemType a)//输出结点数据值
{
    cout<<a<<" ";
}

void ListTraverse(LinkList L, void (*Visit)(ElemType))//遍历线性链表
{
    Link p = L.head->next;
    while(p)
    {
        Visit(p->data);
        p = p->next;
    }
}

int main(int argc, char* argv[])
{
    LinkList L;
    InitList(L);
    Link s;
    char e = 'a';
    MakeNode(s,e);
    InsFirst(L,L.head,s);
    Link t;
    MakeNode(t,'b');
    InsBefore(L,s,t);
    void (*ptr)(ElemType);
    ptr = Visit;
    ListTraverse(L,ptr);
    int (*p)(ElemType,ElemType);
    p = cmp;
    cout<<LocateElm(L,'b',p)->data<<endl;
    LocatePos(L,0,t);
    if(t==L.head?1:0)
        cout<<"OK"<<endl;
    LocatePos(L,ListLength(L),t);
    if(t==L.tail?1:0)
        cout<<"OK"<<endl;
    if(NextPos(L,s)==NULL)
        cout<<"OK"<<endl;
    return 0;
}