数据结构实验报告之链表顺序表的操作

1、编写程序实现顺序表的各种基本运算：初始化、插入、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。在此基础上设计一个主程序完成如下功能：

（1）初始化顺序表L；

（2）依次在表尾插入a，b，c，d，e五个元素；

（3）输出顺序表L；

（4）输出顺序表L的长度；

（5）判断顺序表L是否为空；

（6）输出顺序表L的第4个元素；

（7）输出元素c的位置；

（8）在第3个位置上插入元素f，之后输出顺序表L；

（9）删除L的第2个元素，之后输出顺序表L；

（10）销毁顺序表L。

2、编写程序实现单链表的各种基本运算：初始化、插入、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。在此基础上设计一个主程序完成如下功能：

（1）初始化单链表L；

（2）依次在表尾插入a，b，c，d，e五个元素；

（3）输出单链表L；

（4）输出单链表L的长度；

（5）判断单链表L是否为空；

（6）输出单链表L的第4个元素；

（7）输出元素c的位置；

（8）在第3个位置上插入元素f，之后输出单链表L；

（9）删除L的第2个元素，之后输出单链表L；

（10）销毁单链表L。

顺序表
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

#define  TRUE     1
#define  FALSE    0
#define  OK           1
#define  ERROR   0
#define  INFEASIBLE  -1
#define  OVERFLOW  -2
typedef  int  Status;
typedef  char ElemType;

#define   LIST_INIT_SIZE    100                                                                        //线性表存储空间的初始分配量
#define   LISTINCREMENT   10                                                                        //线性表存储空间的分配增量
typedef  struct {
    ElemType  *elem;                                                                                  //存储空间基地址
    int    length;                                                                                  //当前长度
    int    listsize;                                                                                //当前分配的存储容量
} SqList;

Status InitList_Sq(SqList &L) {                                                                    //算法2.3
    L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
    if (!L.elem) exit(OVERFLOW);                                                                     //存储分配失败
    L.length = 0;                                                                                    //空表长度为0
    L.listsize = LIST_INIT_SIZE;                                                                        //初始存储容量
    return OK;
}//InitList_Sq

Status ListInsert_Sq(SqList &L, int i, ElemType e) {                                                //算法2.4
    ElemType *newbase, *p, *q;
    if (i<1 || i>L.length + 1)   return  ERROR;                                                    //i值不合法
    if (L.length >= L.listsize)
    {                                                                                                //当前存储空间已满，增加分配
        newbase = (ElemType*)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));
        if (!newbase)  exit(OVERFLOW);                                                                //存储分配失败
        L.elem = newbase;                                                                                //新基址
        L.listsize += LISTINCREMENT;                                                                    //增加存储容量
    }
    q = &(L.elem[i - 1]);                                                                                //q为插入位置
    for (p = &(L.elem[L.length - 1]); p >= q; --p)  *(p + 1) = *p;                                                //元素右移
    *q = e;                                                                                              //插入e
    ++L.length;                                                                                        //表长增1
    return OK;
}

void DispSqList(SqList L)
{
    int i;
    for (i = 0; i < L.length; i++)
        printf("%c ", L.elem[i]);
}

Status ListDelete(SqList &L, int i, ElemType &e)
{
    ElemType  *p,*q;
    if ((i < 1) || (i > L.length)) return ERROR;
    p = &(L.elem[i - 1]);
    e = *p;
    q = L.elem + L.length - 1;
    for (++p; p <= q; ++p)
        *(p - 1) = *p;
    --L.length;
    return OK;
} //ListDelete_Sq

Status GetElem(SqList L, int i, ElemType &e)
{
    if (L.length == 0 || i<1 || i>L.length)
        return ERROR;
    e = L.elem[i - 1];
    return OK;
}

int ListLength(SqList L)
{
    return(L.length);
}

Status DestroyList(SqList &L)
{
    free(L.elem);
    L.length = 0;
    return OK;
}

Status ListEmpty(SqList L)
{
    return(L.length == 0);
}

int LocateElem(SqList L, ElemType e)
{
    int i = 0;
    while (i < L.length && L.elem[i] != e) i++;
    if (i >= L.length)  return 0;
    else  return i + 1;
}

void main()
{
    SqList  h;
    ElemType e;
    InitList_Sq(h);
    ListInsert_Sq(h, h.length + 1, 'a');
    ListInsert_Sq(h, h.length + 1, 'b');
    ListInsert_Sq(h, h.length + 1, 'c');
    ListInsert_Sq(h, h.length + 1, 'd');
    ListInsert_Sq(h, h.length + 1, 'e');
    DispSqList(h);
    printf("%d

",ListLength(h));
    ListEmpty(h);
    if (ListEmpty(h))
    {
        printf("Empty

");
    }
    else
    {
        printf("Not empty

");
    }
    GetElem(h, 4, e);
    printf("%c
", e);
    printf("%d
",LocateElem(h, 'c'));
    ListInsert_Sq(h,3,' f');
    DispSqList(h);
    ListDelete(h, 2, e);
    DispSqList(h);
    DestroyList(h);
}





单链表



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

#define  TRUE     1
#define  FALSE    0
#define  OK           1
#define  ERROR   0
#define  INFEASIBLE  -1
#define  OVERFLOW  -2
typedef  int  Status;

typedef  char ElemType;


typedef  struct LNode {
    ElemType    data;
    int length;
    struct  LNode  *next;
}LNode, *LinkList;


Status InitList_L(LinkList &L) {
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    return OK;
}

Status ListInsert_L(LinkList L, int i, ElemType e) {
    LinkList p = L,s;
    int j = 0;
    while (p && j < i - 1)
    {
        p = p->next;
        ++j;
    }
    if (!p || j > i - 1) 
    { 
        return ERROR; 
    }
    else
    {
        s = (LinkList)malloc(sizeof(LNode));
        s->data = e;
        s->next = p->next;
        p->next = s;
        return OK;
    }
}

void DispList_L(LinkList L)
{
    LinkList p = L->next;
    while (p != NULL)
    {
        printf("%c
", p->data);
        p = p->next;
    }

}

void DestoryList(LinkList &L)
{
    LinkList p = L, q = p->next;
    while (q != NULL)
    {
        free(p);
        p = q;
        q = p->next;
    }
    free(p);
}

Status ListLength_L(LinkList L) {
    LinkList p = L; int n = 0;
    while (p->next != NULL)
    {
        n++;
        p = p->next;
    }
    return (n);
}

Status ListDelete(LinkList L, int i, ElemType &e){
    int j;
    LinkList p, q;
    p = L; 
    j = 1;
    while (p->next && j < i)
    {
        p = p->next;
        ++j;
    }
    if (!(p->next) || j > i)
    {
        return ERROR;
    }
    q = p->next;
    p->next = q->next;
    e = q->data;
    free(q);
    return OK;
}

Status ListEmpty_L(LinkList L)
{
    return(L->length == 0);
}

Status GetElem(LinkList L, int i, ElemType &e)
{
    int j;
    LinkList p;
    p = L->next;
    j = 1;
    while (p&&j<i)
    {
        p = p->next;
        ++j;
    }
    if (!p || j > i)
    {
        return ERROR;
    }
    e = p->data;
    return OK;
}

Status LocateElem(LinkList L, int e)
{
    LinkList p = L;
    int n=0;
    //p->length = 0;
    while (p != NULL)
    {
        if(p->data != e)
        {
            p = p->next;
            n++;
        }
        else
        {
            break;
        }
    }
    if(p != NULL)
    {
        return n;
    }
    else
    {
        return ERROR;
    }
}

void main()
{
    LinkList  h;
    ElemType e;
    InitList_L(h);
    ListInsert_L(h, 1, 'a');
    ListInsert_L(h, 2, 'b');
    ListInsert_L(h, 3, 'c');
    ListInsert_L(h, 4, 'd');
    ListInsert_L(h, 5, 'e');
    DispList_L(h);
    printf("%d
", ListLength_L(h));
    if (ListEmpty_L(h))
    {
        printf("Empty

");
    }
    else
    {
        printf("Not empty

");
    }
    GetElem(h, 4, e);
    printf("%c
", e);
    printf("%d
", LocateElem(h, 'c'));
    ListInsert_L(h, 3, 'f');
    DispList_L(h);
    ListDelete(h, 2, e);
    DispList_L(h);
    DestoryList(h);
}