编写顺序表的插入和删除算法_（数据结构）1.实现顺序表的各种基本运算的算法 2.实现单链表的各种基本运算的算法...

柔情只为你懂 2023-01-12 10:28 93阅读 0赞

## 实验内容 ##

1.编写一个程序sqlist.cpp，实现顺序表的各种基本运算和整体建表算法(假设顺序表的元素类型ElemType为char)，并在此基础上设计一个程序exp2-1.cpp完成以下功能。  
(1)初始化顺序表L。  
(2)依次插入a、b、c、d、e元素。  
(3)输出顺序表L。  
(4)输出顺序表L的长度。  
(5)判断顺序表L是否为空。  
(6)输出顺序表L的第3个元素。  
(7)输出元素a的位置。  
(8)在第4个元素位置上插入f元素。  
(9)输出顺序表L。  
(10)删除顺序表L的第3个元素。  
(11)输出顺序表L。  
(12)释放顺序表L。  
2.编写一个程序linklist.cpp，实现单链表的各种基本运算和整体建表算法(假设单链表的元素类型ElemType为char)，并在此基础上设计一个程序exp2-2.cpp完成以下功能。  
(1)初始化单链表h。  
(2)依次采用尾插法插入a、b、c、d、e元素。  
(3)输出单链表h。  
(4)输出单链表h的长度。  
(5)判断单链表h是否为空。  
(6)输出单链表h的第3个元素。  
(7)输出元素a的位置。  
(8)在第4个元素位置上插入f元素。  
(9)输出单链表h。  
(10)删除单链表h的第3个元素。  
(11)输出单链表h。  
(12)释放单链表h。

## 代码实现 ##

1、sqlist.cpp

#include 
    #include 
    #include 
    using namespace std;  
    typedef char ElemType;  
    #define Maxsize 50  
    typedef struct  
    {  
        ElemType data[Maxsize];  
        int length;  
    }SqList;  
    void InitList(SqList *&L)  //初始化线性表  
    {  
        L=(SqList *)malloc(sizeof(SqList)); //分配存放线性表的空间  
        L->length=0;                        //置空线性表长度为0  
    }  
    void DestroyList(SqList *L)  //销毁线性表  
    {  
        free(L);  
    }  
    bool ListEmpty(SqList *L) //判断线性表是否为空  
    {  
        return (L->length==0);  
    }  
    int ListLength(SqList *L) //求线性表的长度  
    {  
        return (L->length);  
    }  
    void DispList(SqList *L) //输出线性表  
    {  
        int i;  
        if(L->length==0) return;  
        for(i=0;ilength;i++)  
            printf("%c ",L->data[i]);  
        printf("\n");  
    }  
    bool GetElem(SqList *L,int i,ElemType &e)  //求线性表中某个元数的值  
    {  
        if(i<1||i>L->length)  
            return false;  
        e=L->data[i];  
        return true;  
    }  
    int LocateElem (SqList *L,ElemType e)  //按元素值查找  
    {  
        int i=0;  
        while(ilength&&L->data[i]!=e)  
            i++;  
        if(i>=L->length)  
            return 0;  
        else  
            return i+1 ;  
    }  
    bool ListInsert(SqList *L,int i,ElemType e)  //插入数据元素  
    {  
        int j;  
        if(i<1||i>L->length)  
            return false;  
        i--;  
        for(j=L->length;j>i;j--)  
            L->data[j]=L->data[j-1];  
        L->data[i]=e;  
        L->length++;  
        return true;  
    }  
    bool ListDelete(SqList *L,int i,ElemType e)  
    {  
        //int j;  
        if(i<1||i>L->length)  
            return false;  
        i--;  
        e=L->data[i];  
        for(;ilength-1;i++)  
        {  
            L->data[i]=L->data[i+1];  
        }  
        L->length--;  
        return true;  
    }

exp2-1.cpp

2、linklist.cpp

#include 
    #include 
    #include 
    using namespace std;  
    typedef char ElemType;  
    //#define Maxsize 50  
    typedef struct  LNode //定义单链表结点类型  
    {  
        ElemType data;  
        struct LNode *next;  
    }LinkList;  
    void InitList(LinkList *&L)  //初始化单链表  
    {  
        L=(LinkList *)malloc(sizeof(LinkList)); //创建头结点  
        L->next=NULL;  
    }  
    void DestroyList(LinkList *L)  //销毁单链表  
    {  
        LinkList *p=L,*q=L->next;  
        while(q!=NULL)  
        {  
            free(p);  
            p=q;  
            q=p->next;  
        }  
        free(p);  
    }  
    bool ListEmpty(LinkList *L) //判断单链表是否为空  
    {  
        return (L->next==NULL);  
    }  
    int ListLength(LinkList *L) //求单链表的长度  
    {  
       LinkList *p=L;  
       int i=0;  
       while(p->next!=NULL)  
       {  
           i++;  
           p=p->next;  
       }  
       return (i);  
    }  
    void DispList(LinkList *L) //输出单链表  
    {  
       LinkList *p=L->next;  
      // int i=0;  
       while(p->next!=NULL)  
       {  
           printf("%c ",p->data);  
           p=p->next;  
       }  
       printf("%c ",p->data);  
       printf("\n");  
    }  
    bool GetElem(LinkList *L,int i,ElemType &e)  //求单链表中某个元数的值  
    {  
        LinkList *p=L;  
       int j=0;  
       while(p!=NULL&&j   {  
           j++;  
           p=p->next;  
       }  
       if(p==NULL)  
        return false;  
       else  
        {  
            e=p->data;  
            return true;  
        }  
    }  
    int LocateElem (LinkList *L,ElemType e)  //按元素值查找  
    {  
        LinkList *p=L;  
       int j=0;  
       while(p!=NULL&&p->data==e)  
       {  
           j++;  
           p=p->next;  
       }  
       if(p==NULL)  
        return 0;  
       else  
        {  
            return (j+1);  
        }  
    }  
    bool ListInsert(LinkList *L,int i,ElemType e)  //插入数据元素  
    {  
       LinkList *p=L,*s;  
       int j=0;  
       while(p!=NULL&&j   {  
           j++;  
           p=p->next;  
       }  
       if(p==NULL)  
        return false;  
       else  
        {  
            s=(LinkList *)malloc(sizeof(LinkList));  
            s->data=e;  
            s->next=p->next;  
            p->next=s;  
            return true;  
        }  
    }  
    bool ListDelete(LinkList *L,int i,ElemType &e)  
    {  
       LinkList *p=L,*s;  
       int j=0;  
       while(p!=NULL&&j   {  
           j++;  
           p=p->next;  
       }  
       if(p==NULL)  
        return false;  
       else  
        {  
            s=p->next;  
            if(s==NULL)  
                return false;  
            e=s->data;  
            p->next=s->next;  
            free(s);  
            return true;  
        }  
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45
 *  46
 *  47
 *  48
 *  49
 *  50
 *  51
 *  52
 *  53
 *  54
 *  55
 *  56
 *  57
 *  58
 *  59
 *  60
 *  61
 *  62
 *  63
 *  64
 *  65
 *  66
 *  67
 *  68
 *  69
 *  70
 *  71
 *  72
 *  73
 *  74
 *  75
 *  76
 *  77
 *  78
 *  79
 *  80
 *  81
 *  82
 *  83
 *  84
 *  85
 *  86
 *  87
 *  88
 *  89
 *  90
 *  91
 *  92
 *  93
 *  94
 *  95
 *  96
 *  97
 *  98
 *  99
 *  100
 *  101
 *  102
 *  103
 *  104
 *  105
 *  106
 *  107
 *  108
 *  109
 *  110
 *  111
 *  112
 *  113
 *  114
 *  115
 *  116
 *  117
 *  118
 *  119
 *  120
 *  121
 *  122
 *  123
 *  124
 *  125
 *  126
 *  127
 *  128
 *  129

exp2-2.cpp

## 结果截图 ##

1、![6dfe67a398a59dbc316380829b2d7fc1.png][]  
2.![d2baafdba5f9ff0ecd1c6a8c86cb5c52.png][]

原文链接：

https://blog.csdn.net/weixin\_41032720/article/details/94835389

[6dfe67a398a59dbc316380829b2d7fc1.png]: /images/20221119/cb91f43d337e465d8a17a74df58b3d35.png
[d2baafdba5f9ff0ecd1c6a8c86cb5c52.png]: /images/20221119/3eb7443d433145f29ea39e4b1f844f14.png