程序实例---线性表的顺序实现和链式实现

 顺序实现

.h文件 此文件为方法
#ifndef SQLIST_H_INCLUDED
#define SQLIST_H_INCLUDED
#include "ds.h" //for Status,OK ...
#ifndef ElemType
#define ElemType int /* 数据元素类型默认为 int */
#define ELEMTYPE_TAG
#endif
/**********************************************************
*  顺序表的存储结构定义
***********************************************************/
#define LIST_INIT_SIZE 100 /* 存储空间初始分配容量 */
#define LISTINCREMENT 10 /* 存储空间分配的增量 */
typedef struct {
    ElemType *elem;    //存储空间基址
    int length;        //当前长度
    int listsize;      //当前已分配的存储空间(元素个数)
} SqList;
/**********************************************************
*  顺序表的基本操作声明
***********************************************************/
//创建并初始化为空表
Status InitList(SqList &L);
//销毁整个表(从此之后不再可用)
Status DestroyList(SqList &L);
//将表L置空
Status ClearList(SqList &L);
//判断表L是否为空表
bool ListEmpty(SqList L);
//求表L的长度
int ListLength(SqList L);
//取表L中的第i个元素,并用e返回. 操作成功返回OK,失败时返回ERROR
Status GetElem(SqList L, int i, ElemType &e);
template <typename T> bool equal(T a, T b)
{
    return a==b;
}
//在表L中定位元素e首次出现的位置. 操作成功返回位序,失败时返回0
//    compare(a,b) 为比较函数,匹配时返回true,否则返回false
//                 这里默认使用equal进行比较
int LocateElem(SqList L, ElemType e,
      bool (*compare)(ElemType,ElemType)=equal<ElemType>);
//在表L中插入第i个元素e. 操作成功返回OK,失败时返回ERROR
Status ListInsert(SqList &L, int i, ElemType e);
//删除表L中第i个元素,结果用e返回. 操作成功返回OK,失败时返回ERROR
Status ListDelete(SqList &L, int i, ElemType &e);
//遍历表L,对每个元素调用visit(x).
Status ListTraverse(SqList L, Status (*visit)(ElemType));
/**********************************************************
*  顺序表的基本操作的实现
***********************************************************/
//创建并初始化为空表
Status InitList(SqList &L)
{
    // TODO (#1#): 创建空表
    L.elem=(ElemType*)malloc(LIST_INIT_SIZE * sizeof(ElemType));
    if(!L.elem)exit(OVERFLOW);
    L.length=0;
    L.listsize=LIST_INIT_SIZE;
    return OK;
    //-------------------------------------
}
//销毁整个表(从此之后不再可用)
Status DestroyList(SqList &L)
{
    free(L.elem);
    return OK;
    //-------------------------------------
}
//将表L置空
Status ClearList(SqList &L)
{
    // TODO (#1#): 清空表
    L.length=0;
    return OK;
    //-------------------------------------
}
//判断表L是否为空表
bool ListEmpty(SqList L)
{
    // TODO (#1#): 顺序表判空
    if(L.length==0)
        return TRUE;
    else
    return FALSE;
    //-------------------------------------
}

//求表L的长度
int ListLength(SqList L)
{
    // TODO (#1#): 求顺序表长度
    return  L.length;
    //-------------------------------------
}

//取表L中的第i个元素,并用e返回. 操作成功返回OK,失败时返回ERROR
Status GetElem(SqList L, int i, ElemType &e)
{
    // TODO (#1#): 取元素
    if(ListEmpty(L))
    {
        printf("线性表L为空\n");
        return ERROR;
    }
    if(i<1||i>L.length)
    {
        printf("不存在%d位置的元素\n",i);
        return ERROR;
    }
    e=L.elem[i-1];
    return OK;
    //-------------------------------------
}

//在表L中定位元素e首次出现的位置. 操作成功返回位序,失败时返回0
//    compare(a,b) 为比较函数,匹配时返回true,否则返回false
int LocateElem(SqList L, ElemType e, bool (*compare)(ElemType,ElemType))
{
    // TODO (#1#): 在表中定位元素e,用compare(a,b)匹配元素
    for (int j=0; j<L.length; j++)
        if ( compare(L.elem[j],e) )  return j+1;
    return 0;
    //-------------------------------------
}


//在表L中插入第i个元素e. 操作成功返回OK,失败时返回ERROR
Status ListInsert(SqList &L, int i, ElemType e)
{
    // TODO (#1#): 在链表中插入元素
    if(i<1 || i>L.length+1)
        return ERROR;
     if (L.length >= L.listsize) //判读存储空间是否已满
    {
        ElemType * newbase = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));
        if (!newbase)
            exit(OVERFLOW);
        L.elem = newbase;
        LL.listsize = L.listsize + LISTINCREMENT;
    }
    ElemType *q = &(L.elem[i - 1]); //q指向第i个元素
    ElemType *p;                     //p指向最后一个元素

    for (p= &(L.elem[L.length - 1]); p >= q; p--) //从最后一个位置开始移动
    {
        *(p + 1) = *p;
    }

    *q = e;
    L.length++;
    return ERROR;
    //-------------------------------------
}

//删除表L中第i个元素,结果用e返回. 操作成功返回OK,失败时返回ERROR
Status ListDelete(SqList &L, int i, ElemType &e)
{
    // TODO (#1#): 在顺序表中删除元素
if (L.length == 0) //判断表是否为空
    {
        printf("表为空\n");
        return ERROR;
    }

    if (i < 1 || i > L.length) //判断删除位置是否合法
    {
        printf("删除位置不合法\n");
        return ERROR;
    }

    ElemType *p = &(L.elem[i - 1]); //p指向待删除的元素
    e = *p;
    ElemType *q = &(L.elem[L.length - 1]);
    //ElemType *q = L->elem + L->length - 1; //q指向最后一个元素
    for (pp = p + 1; p <= q; p++) //p从待删除的后一个元素开始，直到最后一个元素，每个元素一次向前移动一个位置
    {
        *(p - 1) = *p;
    }

    L.length--; //最后，线性表长度减一

    return OK;
    //-------------------------------------
}

//遍历表L,对每个元素调用visit(x).
Status ListTraverse(SqList L, Status (*visit)(ElemType))
{
    // TODO (#1#): 遍历顺序表
    for (int j=0; j<L.length; j++)
        if ( ! visit(L.elem[j]) )  return ERROR;
    return OK;
    //-------------------------------------
}

.cpp文件 此文件为主函数
#ifdef ELEMTYPE_TAG
#undef ElemType
#undef ELEMTYPE_TAG
#endif
#endif  // SQLIST_H_INCLUDED
#include <stdio.h>
#include <stdlib.h>
#include "ds.h"
#define ElemType int                 //数据元素的类型
Status print(ElemType e);            // 打印数据元素的方法
bool equal(ElemType a, ElemType b);  //比较两个元素相等的方法
#include "sqlist.h"
//打印顺序表内容
void PrintLinkList(SqList L);
int main()
{
    SqList L;

    //1)初始化顺序表
    InitList(L);

    //2)插入一些元素: 12,23,34,45
    ListInsert(L,1,12);
    ListInsert(L,1,23);
    ListInsert(L,1,34);
    ListInsert(L,1,45);

    //3)打印顺序表信息
    printf("\n开始时顺序表内容\n");
    PrintLinkList(L);
    printf("ListLength(L) : %d\n", ListLength(L));
    printf("ListEmpty(L)  : %d\n", ListEmpty(L));

    //4)顺序表插入
    printf("\n请输入一个元素:");
    ElemType x;
    read(x);
    printf("插入开头:");
    ListInsert(L,1,x);
    PrintLinkList(L);
    printf("插入末尾:");
    ListInsert(L,ListLength(L)+1,x);
    PrintLinkList(L);

    //5)顺序表删除
    printf("\n请选择删除第i(1..%d)个元素:", ListLength(L));
    int i;
    read(i);
    ElemType e;
    if ( ListDelete(L,i,e)==OK ) {
        Status print(ElemType e);  //声明print(e)函数

        printf("删除"); print(e);
        printf("成功\n");
    } else
        printf("删除失败.\n");
    printf("顺序表内容:");
    PrintLinkList(L);

    //6)元素定位
    printf("\n请输入一个元素以便定位:");
    read(x);
    i = LocateElem(L,x);
    if ( i!=0 ) {
        printf("该元素是表中的第%d个元素.\n",i);
    } else
        printf("该元素在表中不存在.\n");

    //7)清空顺序表
    ClearList(L);
    printf("\n最后顺序表内容\n");
    PrintLinkList(L);
    printf("ListLength(L) : %d\n", ListLength(L));
    printf("ListEmpty(L)  : %d\n", ListEmpty(L));

    //8)销毁顺序表
    DestroyList(L);

    system("PAUSE");
    return 0;
}

// 打印数据元素的方法
Status print(ElemType e)
{
    printf("%5d",e);
    return OK;
}

//比较两个元素相等的方法
bool equal(ElemType a, ElemType b)
{
    return a==b;
}

//打印顺序表内容
void PrintLinkList(SqList L)
{
    ListTraverse(L,print); //遍历顺序表并print()每个元素
    printf("\n");
}

 线性表的链式实现

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

#include "ds.h"

#define ElemType int                 //数据元素的类型
Status print(ElemType e);            // 打印数据元素的方法
bool equal(ElemType a, ElemType b);  //比较两个元素相等的方法

#include "linklist.h"

//打印链表内容
void PrintLinkList(LinkList L);

int main()
{
    LinkList L;

    //1)初始化链表
    InitList(L);

    //2)插入一些元素: 12,23,34,45
    ListInsert(L,1,12);
    ListInsert(L,1,23);
    ListInsert(L,1,34);
    ListInsert(L,1,45);

    //3)打印链表信息
    printf("\n开始时链表内容\n");
    PrintLinkList(L);
    printf("ListLength(L) : %d\n", ListLength(L));
    printf("ListEmpty(L)  : %d\n", ListEmpty(L));

    //4)链表插入
    printf("\n请输入一个元素:");
    ElemType x;
    read(x);
    printf("插入开头:");
    ListInsert(L,1,x);
    PrintLinkList(L);
    printf("插入末尾:");
    ListInsert(L,ListLength(L)+1,x);
    PrintLinkList(L);

    //5)链表删除
    printf("\n请选择删除第i(1..%d)个元素:", ListLength(L));
    int i;
    read(i);
    ElemType e;
    if ( ListDelete(L,i,e)==OK ) {
        Status print(ElemType e);  //声明print(e)函数

        printf("删除"); print(e);
        printf("成功\n");
    } else
        printf("删除失败.\n");
    printf("链表内容:");
    PrintLinkList(L);

    //6)元素定位
    printf("\n请输入一个元素以便定位:");
    read(x);
    i = LocateElem(L,x);
    if ( i!=0 ) {
        printf("该元素是表中的第%d个元素.\n",i);
    } else
        printf("该元素在表中不存在.\n");

    //7)清空链表
    ClearList(L);
    printf("\n最后链表内容\n");
    PrintLinkList(L);
    printf("ListLength(L) : %d\n", ListLength(L));
    printf("ListEmpty(L)  : %d\n", ListEmpty(L));

    //8)销毁链表
    DestroyList(L);

    system("PAUSE");
    return 0;
}

// 打印数据元素的方法
Status print(ElemType e)
{
    printf("%5d",e);
    return OK;
}

//比较两个元素相等的方法
bool equal(ElemType a, ElemType b)
{
    return a==b;
}

//打印链表内容
void PrintLinkList(LinkList L)
{
    ListTraverse(L,print); //遍历链表并print()每个元素
    printf("\n");
}

 

#ifndef LINKLIST_H_INCLUDED
#define LINKLIST_H_INCLUDED

#include "ds.h" //for Status,OK ...

#ifndef ElemType
#define ElemType int /* 数据元素类型默认为 int */
#define ELEMTYPE_TAG
#endif

/**********************************************************
*  单链表的存储结构定义
***********************************************************/
typedef struct LNode {
    ElemType data;
    struct LNode *next;
} LNode, *LinkList;


/**********************************************************
*  单链表的基本操作声明
***********************************************************/

//创建并初始化为空表
Status InitList(LinkList &L);

//销毁整个表(从此之后不再可用)
Status DestroyList(LinkList &L);

//将表L置空
Status ClearList(LinkList &L);

//判断表L是否为空表
bool ListEmpty(LinkList L);

//求表L的长度
int ListLength(LinkList L);

//取表L中的第i个元素,并用e返回. 操作成功返回OK,失败时返回ERROR
Status GetElem(LinkList L, int i, ElemType &e);

template <typename T> bool equal(T a, T b)
{
    return a==b;
}
//在表L中定位元素e首次出现的位置. 操作成功返回位序,失败时返回0
//    compare(a,b) 为比较函数,匹配时返回true,否则返回false
//                 这里默认使用equal进行比较
int LocateElem(LinkList L, ElemType e,
      bool (*compare)(ElemType,ElemType)=equal<ElemType>);

//在表L中插入第i个元素e. 操作成功返回OK,失败时返回ERROR
Status ListInsert(LinkList &L, int i, ElemType e);

//删除表L中第i个元素,结果用e返回. 操作成功返回OK,失败时返回ERROR
Status ListDelete(LinkList &L, int i, ElemType &e);

//遍历表L,对每个元素调用visit(x).
Status ListTraverse(LinkList L, Status (*visit)(ElemType));


/**********************************************************
*  单链表的基本操作的实现
***********************************************************/

//创建并初始化为空表
Status InitList(LinkList &L)
{
    // TODO (#1#): 创建空表
    L=(LinkList)malloc(sizeof(LNode));
    if(!L) exit(OVERFLOW);
    L->next=NULL;
    return OK;
    //-------------------------------------
}

//销毁整个表(从此之后不再可用)
Status DestroyList(LinkList &L)
{
    // TODO (#1#): 销毁表
    LinkList q;
    while(L)
    {
        q=L->next;
        free(L);
        L=q;
    }
    return OK;
    //-------------------------------------
}

//将表L置空
Status ClearList(LinkList &L)
{
    // TODO (#1#): 清空表
    LinkList p,q;
    p=L->next;
    while(p)
    {
       q=p->next;
       free(p);
       p=q;
    }
    L->next=NULL;
    return OK;
    //-------------------------------------
}

//判断表L是否为空表
bool ListEmpty(LinkList L)
{
    // TODO (#1#): 链表判空
     if(L->next==NULL)
         return TRUE;
     else
    return FALSE;
    //-------------------------------------
}

//求表L的长度
int ListLength(LinkList L)
{
    // TODO (#1#): 链表求长度
    LinkList p=L;
    int length=0;
    while(p->next)
    {
       ++length;
       pp=p->next;
    }
    return length;
    //-------------------------------------
}

//取表L中的第i个元素,并用e返回. 操作成功返回OK,失败时返回ERROR
Status GetElem(LinkList L, int i, ElemType &e)
{
    // TODO (#1#): 实现取元素GetElem(L,i,&e)
    LinkList p;
    int j=1;
    p=L->next;
    while(p && j<i)
    {
        pp=p->next;
        j++;
    }
    if(!p||j>i) return ERROR;
    e=p->data;
    return OK;
    //-------------------------------------
}

//在表L中定位元素e首次出现的位置. 操作成功返回位序,失败时返回0
//    compare(a,b) 为比较函数,匹配时返回true,否则返回false
int LocateElem(LinkList L, ElemType e, bool (*compare)(ElemType,ElemType))
{
    // TODO (#1#): 在表中定位元素e,用compare(a,b)匹配元素
    LinkList p;
   int j;
   p = L->next; j = 0;
    while(p!=NULL) {
        j++;
        if( compare(p->data,e) )  return j;
        pp=p->next;
    }
    return 0;
    //-------------------------------------
}


//在表L中插入第i个元素e. 操作成功返回OK,失败时返回ERROR
Status ListInsert(LinkList &L, int i, ElemType e)
{
    // TODO (#1#): 在链表中插入元素
    LinkList p=L; int j=0;
    while(p && j<i-1)
    {
        pp=p->next;
        j++;
    }
    if(!p||j>i-1)return ERROR;
    LinkList s=(LinkList)malloc (sizeof(LNode));
    s->data=e; s->next=NULL;
    s->next=p->next; p->next=s;
    return OK;
    //-------------------------------------
}

//删除表L中第i个元素,结果用e返回. 操作成功返回OK,失败时返回ERROR
Status ListDelete(LinkList &L, int i, ElemType &e)
{
    // TODO (#1#): 在链表中删除元素
    LinkList p=L;
    LinkList q;
    int j=0;
    while(p->next && j<i-1)
    {
       pp=p->next;
       j++;
    }
    if(!(p->next)||j>i-1) return ERROR;
    q=p->next;
    p->next=q->next;
    e=q->data;
    free(q);
    return OK;
    //-------------------------------------
}

//遍历表L,对每个元素调用visit(x).
Status ListTraverse(LinkList L, Status (*visit)(ElemType))
{
    LinkList p = L->next;
    while ( p ) {
        if ( visit(p->data)==ERROR )  return ERROR;
        pp = p->next;
    }
    return OK;
}


#ifdef ELEMTYPE_TAG
#undef ElemType
#undef ELEMTYPE_TAG
#endif

#endif  // LINKLIST_H_INCLUDED