（数据结构）1.实现顺序表的各种基本运算的算法 2.实现单链表的各种基本运算的算法

最新推荐文章于 2022-12-01 18:32:00 发布
最新推荐文章于 2022-12-01 18:32:00 发布
阅读量2.8w 收藏 273
点赞数 53
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41032720/article/details/94835389
版权

实验内容

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 <iostream>  
#include <stdio.h>  
#include <malloc.h>  
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;i<L->length;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(i<L->length&&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(;i<L->length-1;i++)  
    {  
        L->data[i]=L->data[i+1];  
    }  
    L->length--;  
    return true;  
}

exp2-1.cpp

#include <iostream>  
#include <stdio.h>  
#include <malloc.h>  
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;i<L->length;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(i<L->length&&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(;i<L->length-1;i++)  
    {  
        L->data[i]=L->data[i+1];  
    }  
    L->length--;  
    return true;  
}  
int main()  
{  
    SqList *L;  
    ElemType e;  
    cout<<"顺序表的基本运算："<<endl;  
    cout<<"(1)初始化顺序表L："<<endl;  
    InitList(L);  
    cout<<"(2)依此插入a,b,c,d,e元素："<<endl;  
    ListInsert(L,1,'a');  
    ListInsert(L,2,'b');  
    ListInsert(L,3,'c');  
    ListInsert(L,4,'d');  
    ListInsert(L,5,'e');  
    cout<<"(3)输出顺序表L："<<endl;  
    DispList(L);  
    cout<<"(4)顺序表L长度为："<<ListLength(L)<<endl;  
    printf("(5)顺序表L为%s\n",(ListEmpty(L)?"空":"非空"));  
    GetElem(L,3,e);  
    cout<<"(6)顺序表L的第3个元素是："<<e<<endl;  
    cout<<"(7)元素a的位置："<<LocateElem(L,'a')<<endl;  
    cout<<"(8)在第4个元素位置上插入f元素："<<endl;  
    ListInsert(L,4,'f');  
    cout<<"(9)输出顺序表L:"<<endl;  
    DispList(L);  
    cout<<"(10)删除h的第3个元素："<<endl;  
    ListDelete(L,3,e);  
    cout<<"(11)输出顺序表L："<<endl;  
    DispList(L);  
    cout<<"(12)释放顺序表L："<<endl;  
    DestroyList(L);  
}

2、
linklist.cpp

#include <iostream>  
#include <stdio.h>  
#include <malloc.h>  
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<i)  
   {  
       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<i-1)  
   {  
       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<i-1)  
   {  
       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;  
    }  
}

exp2-2.cpp

#include <iostream>  
#include <stdio.h>  
#include <malloc.h>  
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<i)  
   {  
       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<i-1)  
   {  
       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<i-1)  
   {  
       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;  
    }  
}  
int main()  
{  
    LinkList *h;  
    ElemType e;  
    cout<<"单链表的基本运算如下："<<endl;  
    cout<<"(1)初始化单链表h："<<endl;  
    InitList(h);  
    cout<<"(2)依此采用尾插法插入a,b,c,d,e元素："<<endl;  
    ListInsert(h,1,'a');  
    ListInsert(h,2,'b');  
    ListInsert(h,3,'c');  
    ListInsert(h,4,'d');  
    ListInsert(h,5,'e');  
    cout<<"(3)输出单链表h："<<endl;  
    DispList(h);  
    cout<<"(4)单链表h长度为："<<ListLength(h)<<endl;  
    printf("(5)单链表h为%s\n",(ListEmpty(h)?"空":"非空"));  
    GetElem(h,3,e);  
    cout<<"(6)单链表h的第3个元素是："<<e<<endl;  
    cout<<"(7)元素a的位置："<<LocateElem(h,'a')<<endl;  
    cout<<"(8)在第4个元素位置上插入f元素："<<endl;  
    ListInsert(h,4,'f');  
    cout<<"(9)输出单链表h:"<<endl;  
    DispList(h);  
    cout<<"(10)删除单链表h的第3个元素："<<endl;  
    ListDelete(h,3,e);  
    cout<<"(11)输出单链表h："<<endl;  
    DispList(h);  
    cout<<"(12)释放单链表h："<<endl;  
    DestroyList(h);  
}

结果截图

1、
在这里插入图片描述
2.
在这里插入图片描述

哄玛尼呗呗哄
关注
  • 53
    点赞
  • 踩
  • 273
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
编写一个程序实现单链表的各种基本运算（假设顺序表的元数基本类型为Char）
张旺华的博客
07-01 1万+
/* *Copyright (c) 2016, 烟台大学计算机学院 *All rights reserved. *文件名称：main.cpp *作者：张旺华 *完成日期： 2016 年 7 月 1 日 *版本号：v1.0 *问题描述：编写一个程序实现单链表的各种基本运算（假设顺序表的元数基本类型为Char） * */ #include #include #include
顺序表的运算
nufangdongde的专栏
03-31 703
#include #include #include #define MaxSize 50 using namespace std; typedef struct { char data[MaxSize]; int length; }SqList; void InitList(SqList * &L) { L=(SqList *)malloc(sizeof(SqLi
数据结构: 顺序表和单链表的基本运算实现
m0_46669582的博客
10-28 4367
实验题1-1：实现并验证顺序表的各种基本操作 目的：领会顺序表存储结构和掌握顺序表中的各种基本运算算法设计。 内容： 1.首先，创建文件sqlist.h。 a)定义顺序表的结构体类型； b)定义并实现顺序表的基本运算（详见线性表ADT描述）。 2.然后，创建文件exp1-1.c，引用（#include）头文件sqlist.h，依次完成以下内容，对第一步中实现的顺序表进行测试。 （1）初始化顺序表L； （2）采用尾插法依次插入元素a，b，c，d，e； （3）输出顺序表L； （4）输出顺序表L的长度； （5）判
实现顺序表的各种基本运算的算法（超详细）
weixin_45959708的博客
08-08 1万+
//顺序表基本运算算法 #include <stdio.h> #include <malloc.h> #define MaxSize 50 typedef char ElemType; typedef struct { ElemType data[MaxSize]; //存放顺序表元素 int length; //存放顺序表的长度 } SqList; //顺序表的类型 void CreateList(SqList *&L,ElemType a[
实现顺序表的各种基本运算的算法
kklv__lo的博客
09-09 1万+
内容：编写一个程序，实现顺序表的各种基本算法和整体建表算法，并在此基础上设计一个程序，完成以下功能。 (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。 ...
顺序表与单链表基本运算算法.doc
05-31
单链表的其他基本运算算法实现类似于顺序表的基本运算算法实现。 本文对顺序表和单链表的基本运算算法进行了详细的介绍，包括创建、打印、查找、插入和删除等操作。这些算法都是数据结构和算法设计的基础，理解这些...
单链表的各种基本运算的算法.zip
04-23
这个名为"单链表的各种基本运算的算法.zip"的压缩包文件显然包含了一些关于C语言实现单链表基本操作的算法。我们将深入探讨这些知识点。 首先，单链表是由一系列节点组成的，每个节点包含两部分：数据域（用于存储...
数据结构-时间复杂度的计算和顺序表基本运算实现
06-05
任务二是实现顺序表的基本操作，顺序表是一种线性数据结构，所有元素存储在一块连续的内存区域中。以下是实现这些操作的函数框架： 1. `InitList(SqList *&L)`：初始化顺序表，分配内存并设置长度为0。 2. `...
数据结构各章节算法实现（C语言版）.docx
10-12
1. **顺序表**：顺序表是一种简单的数据结构，数据元素按线性顺序排列。文档中包括字符统计、一元多项式相加等练习，这些练习涵盖了对数组的操作，如遍历、计数和合并。 - **字符统计**：统计字符串中各字符出现的...
数据结构C语言单链表上实现插入和删除的算法实验报告.docx
05-30
"数据结构C语言单链表上实现插入和删除的算法实验报告" 本文档是关于数据结构中的单链表实现插入和删除操作的算法实验报告，使用C语言编写，并提供了详细的实验步骤和实验结果。 单链表的基本操作 单链表是一种...
顺序表的各种基本运算
03-17
编写一个程序，实现顺序表的各种基本运算，并在此基础上完成以下功能: 1) 初始化顺序表； 2) 依次采用尾插入法插入a,b,c,d,e元素； 3) 输出顺序表L； 4) 输出顺序表L的长度； 5) 判断顺序表L是否为空； 6) 输出顺序表L的第三个元素； 7) 输出元素a的位置； 8) 在第4个元素位置上插入f元素； 9) 输出顺序表L； 10) 删除L的第3个元素； 11) 输出顺序表L； 12) 释放顺序表。
线性表：顺序表，链表常见基本运算操作大全（基础才是硬道理）
qq_63385279的博客
04-12 1319
顺序表和链表的常见的基础运算操作，基础才是硬道理，走过路过不要错过！
【数据结构】顺序表/链表的运算及实现
weixin_44799923的博客
12-01 868
数据结构的基础知识，包括顺序表/链表运算及实现
单链表基本操作
lvmengmeng
02-27 871
#include #include #define ERROR 0 #define OK    1 typedef int status; typedef int ElemType; typedef struct Node {  ElemType data;  struct Node *next; } LNode,*LinkList; void Build(LinkList
实现循环单链表的各种基本运算和整体建表算法
yyy_zxc的博客
11-06 1584
//---------------实现循环单链表的各种基本运算和整体建表算法----------------- #include<stdio.h> #include<malloc.h> #define ElemType int typedef struct LNode{ ElemType data; struct LNode *next; }LinkNode; //初始化循环单链表 void InitList(LinkNode *&L){ L ...
顺序表的基本运算。
DDraven的博客
09-21 652
问题及代码： /* *Copyright(c) 2015,烟台大学计算机与控制工程学院 *All rights reserved. *文件名称：test.cpp *作 者：刘磊 *完成日期：2015.9.21 *版 本 号：v1.0 * *问题描述：实现顺序表的基本运算。 *输入描述：建立一个线性表。 *程序输出： 线性表的算法D
单链表各种基本运算的算法
Hey3399的博客
04-23 3802
初始化单链表 /初始化单链表 void InitList(LinkNode *&L) { //创建头结点 L=(LinkNode*)malloc(sizeof(LinkNode)); L->next=NULL; } 头插法建立单链表 //头插法建立单链表 void CreateListF(LinkNode *&L,ElemType a[],int n) { //创建头结点 LinkNode *s; L=(LinkNode*)malloc(sizeof(LinkNo
顺序表算法
m0_46219844的博客
03-25 915
顺序表算法 【顺序表算法】设顺序表 A，元素的个数是 n，没有重复。如果 A 中前 k 个元 素有序，后 n-k 个元素有序，设计一个算法使得整个顺序表有序，要求算法的空 间复杂度为 O(1) #include <stdio.h> #include<stdlib.h> #define ElemType int #define Status int #define MaxS...
编写一个程序，实现顺序表的各种基本运算
热门推荐
Stay hungry
11-14 2万+
本实验的顺序表元素的类型为char，完成如下实验要求： （1）初始化顺序表L （2）采用尾插法依次插入a、b、c、d、e （3）输出顺序表L （4）输出顺序表L的长度 （5）判断顺序表L是否为空 （6）输出顺序表的第3个元素 （7）输出元素a的逻辑位置 （8）在第4个元素位置上插入元素f （9）输出顺序表L （10）删除L的第3个元素 （11）输出顺序表L （12）释放顺序
实现顺序表各种基本运算的算法
最新发布
10-04
实现顺序表各种基本运算的算法如下： 1. 初始化顺序表L: 设置L的长度为0。 2. 插入元素：在指定位置插入元素时，需要将插入位置后面的元素依次后移，然后将要插入的元素放在插入位置上，最后将顺序表的长度加一。 3. 输出顺序表L：依次输出顺序表中的每个元素。 4. 输出顺序表L的长度：返回顺序表L的长度。 5. 判断顺序表L是否为空：通过判断顺序表L的长度是否为0来确定顺序表是否为空。 6. 输出顺序表L的第k个元素：返回顺序表L中第k个位置的元素。 7. 输出元素x的位置：从第一个元素开始遍历顺序表L，找到与x相等的元素，返回其位置。 8. 在第k个位置插入元素x：将顺序表L的第k个位置及其后面的元素依次后移，然后将x放在第k个位置上，最后将顺序表的长度加一。 9. 删除顺序表L的第k个元素：将第k个位置后面的元素依次前移，然后将顺序表的长度减一。
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值