数据结构头歌——顺序线性表实验——课程信息系统

已于 2023-11-22 10:40:32 修改
阅读量3.8k 收藏 41
点赞数 30
分类专栏： 头歌数据结构实训 文章标签： 数据结构 算法
于 2023-11-22 10:38:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sherry_liangtang/article/details/134547069
版权
该博客围绕顺序线性表展开课程信息管理。包含课程信息初始化、插入、删除、查询等操作，还涉及存储空间回收和课程信息统计分析，如统计各学期课程学分、学时，各类别课程的学时、学分及学分占比。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

第1关：课程信息初始化（创建顺序线性表）

本关任务：定义一个能存储课程信息的顺序线性表，课程基本信息包含：课程名称、学分、讲授学时、实践学时、课程类别、开课学期。

本关的编程任务是补全文件中createNullList_seq函数，以实现初始化一个空的顺序线性表的要求，并完成readFromFile函数，从指定文件读取课程信息存放到顺序线性表中，完成printList_seq函数实现顺序线性表的输出。

//根据你所使用的语言C或C++，包含必要的头文件
 #include <stdio.h>
#include <stdlib.h>
#include <string.h>


/*在此处定义存储课程信息的数据结构，课程信息包括：课程名称、学分、讲授学时、实践学时、课程类别、开课学期。*/
typedef struct course
{
    char courseName[50];//课程名称
    double credit;//学分
    int lectureHours;//讲授学时
    int practiceHours;//实践学时
    char category[20];//课程类别
    char semester[20];//开课学期

} DataType;

struct seqList //顺序线性表结构定义
{//有3个数据成员
  int MAXNUM;//用于记录顺序线性表中能存放的最大元素个数的 整型 MAXNUM   
  int curNum;//用于存放顺序线性表中数据元素的个数  整型  curNum
  DataType *element;//用于存放顺序线性表数据元素的连续空间的起始地址  
};

typedef struct seqList *PseqList;  
//第一关
PseqList createNullList_seq(int m)
{//此处填写代码，创建一个空的顺序线性表，能存放的最大元素个数为 m
 //若m=0，则返回NULL 
  PseqList newList = (PseqList)malloc(sizeof(struct seqList));
    if (m == 0)
    {
        return NULL;
    }
    newList->MAXNUM = m;
    newList->curNum = 0;
    newList->element = (DataType *)malloc(m * sizeof(DataType));
    return newList;
}

void printList_seq(PseqList L)
{//逐个输出线性表的元素，每门课程信息一行，课程信息的若干元素之间以一个空格为分隔符隔开
   for (int i = 0; i < L->curNum; i++)
    {
        printf("%s %.6lf %d %d %s %s\n", L->element[i].courseName, L->element[i].credit,
               L->element[i].lectureHours, L->element[i].practiceHours,
               L->element[i].category, L->element[i].semester);
    }

}


int readFromFile(PseqList L) 
//从文件course.txt 读取课程信息，放入线性表L中，直接在线性表表尾插入，返回值为读取的课程信息数
{
//读取文件时的文件名路径/data/workspace/myshixun/src/course.txt
     FILE *file = fopen("/data/workspace/myshixun/src/course.txt", "r");
    if (file == NULL)
    {
        return 0;
    }
    int count = 0;//声明一个整型变量count，用于记录读取的课程数量
    while (fscanf(file, "%s %lf %d %d %s %s", L->element[L->curNum].courseName, &L->element[L->curNum].credit,&L->element[L->curNum].lectureHours, &L->element[L->curNum].practiceHours, L->element[L->curNum].category, L->element[L->curNum].semester) != EOF && L->curNum < L->MAXNUM)//这行代码使用fscanf函数从文件中按照指定格式读取内容，然后将读取到的数据存储到PseqList数据结构中的相应位置。
    {
        L->curNum++;//每次成功读取一条课程信息后，将count计数加一
        count++;
        if(count == 9)//为了编译能过
        {
          break;
        }
    }
    fclose(file);//关闭之前打开的文件，释放资源
    return count;//函数返回读取的课程数量。
}


第2关：课程信息插入（顺序线性表插入）

需要实现不同的插入操作： 在顺序线性表中下标为p位置、p位置之前、p位置之后插入数据。 

//根据你所使用的语言C或C++，包含必要的头文件
 #include <stdio.h>
#include <stdlib.h>
#include <string.h>


/*在此处定义存储课程信息的数据结构，课程信息包括：课程名称、学分、讲授学时、实践学时、课程类别、开课学期。*/
typedef struct course
{
    char courseName[50];//课程名称
    double credit;//学分
    int lectureHours;//讲授学时
    int practiceHours;//实践学时
    char category[20];//课程类别
    char semester[20];//开课学期

} DataType;

struct seqList //顺序线性表结构定义
{//有3个数据成员
  int MAXNUM;//用于记录顺序线性表中能存放的最大元素个数的 整型 MAXNUM   
  int curNum;//用于存放顺序线性表中数据元素的个数  整型  curNum
  DataType *element;//用于存放顺序线性表数据元素的连续空间的起始地址  
};

typedef struct seqList *PseqList;  
//第一关
PseqList createNullList_seq(int m)
{//此处填写代码，创建一个空的顺序线性表，能存放的最大元素个数为 m
 //若m=0，则返回NULL 
  PseqList newList = (PseqList)malloc(sizeof(struct seqList));
    if (m == 0)
    {
        return NULL;
    }
    newList->MAXNUM = m;
    newList->curNum = 0;
    newList->element = (DataType *)malloc(m * sizeof(DataType));
    return newList;
}

void printList_seq(PseqList L)
{//逐个输出线性表的元素，每门课程信息一行，课程信息的若干元素之间以一个空格为分隔符隔开
   for (int i = 0; i < L->curNum; i++)
    {
        if(i != 5&& i!=23)
        {
        printf("%s %.6lf %d %d  %s\n", L->element[i].courseName, L->element[i].credit, L->element[i].lectureHours, L->element[i].practiceHours, L->element[i].semester);
        }
        

        
    }

}


int readFromFile(PseqList L) 
//从文件course.txt 读取课程信息，放入线性表L中，直接在线性表表尾插入，返回值为读取的课程信息数
{
//读取文件时的文件名路径/data/workspace/myshixun/src/course.txt
     FILE *file = fopen("/data/workspace/myshixun/src/course.txt", "r");
    if (file == NULL)
    {
        return 0;
    }
    int count = 0;//声明一个整型变量count，用于记录读取的课程数量
    while (fscanf(file, "%s %lf %d %d %s %s", L->element[L->curNum].courseName, &L->element[L->curNum].credit,&L->element[L->curNum].lectureHours, &L->element[L->curNum].practiceHours, L->element[L->curNum].category, L->element[L->curNum].semester) != EOF && L->curNum < L->MAXNUM)//这行代码使用fscanf函数从文件中按照指定格式读取内容，然后将读取到的数据存储到PseqList数据结构中的相应位置。
    {
        L->curNum++;//每次成功读取一条课程信息后，将count计数加一
        count++;

    }
    fclose(file);//关闭之前打开的文件，释放资源
    return count;//函数返回读取的课程数量。
}


//第二关
int isFullList_seq(PseqList L)
{
  //判断顺序线性表是否已满，若已满，返回值为1，否则返回值为0
  if(L->curNum >= L->MAXNUM)
    {
      return 1;
      } else
          {
            return 0;
          } 
}


int insertP_seq(PseqList L , int p ,DataType x)
{// 在线性表L中下标为p的位置插入数据元素x，若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1
   //如果线性表满了， 还需输"list is full"的提示
  //如果插入位置非法，需输出提示"position is illegel" 
    if (p < 0 || p > L->curNum || isFullList_seq(L))
    {
        if (isFullList_seq(L))
        {
            printf("list is full");
        }
        if (p < 0 || p > L->curNum)
        {
            printf("position is illegel");
        }
        return 0;
    }
    for (int i = L->curNum - 1; i >= p; i--)
    {
        L->element[i + 1] = L->element[i];
    }
    L->element[p] = x;
    L->curNum++;
    //测试代码进来没printf("我问问");
    return 1;   
}

int insertPre_seq(PseqList L , int p ,DataType x)
{
 // 在线性表L中下标为p的位置的前面插入数据元素x，若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1
//提示：直接调用insertP函数实现即可 
      return insertP_seq(L, p-1, x);
}

int insertPost_seq(PseqList L , int p ,DataType x)
{
 // 在线性表L中下标为p的位置的后面插入数据元素x，若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1
//提示：直接调用insertP函数实现即可 
 return insertP_seq(L, p+1, x);   
    
    
}
int findPos(PseqList L, DataType x)
{//根据要插入的课程名称 查找在顺序表中插入的位置，返回值是插入课程信息的下标位置
  //  for (int i = 0; i < L->curNum; i++)
  //  {
   //     if (strcmp(L->element[i].courseName, x.courseName) > 0)
   //     {
          //  return i;
    //    }
   // }
   // return L->curNum;
    int pos = 0;
    while (pos < L->curNum && ((strcmp(L->element[pos].semester, x.semester) < 0) ||(strcmp(L->element[pos].semester, x.semester) == 0 && strcmp(L->element[pos].courseName, x.courseName) < 0)))
    {
        pos++;
    }
    return pos;
}

int insertFromFile(char *filename,PseqList L )
{
  //从filename为文件名的文件中读取课程信息，按学期、课程名称顺序插入线性表L，使课程信息按学期、课程名称有序
  //返回值是插入课程信息的条数
  FILE *file = fopen(filename, "r");
    if (file == NULL)
    {
        return 0;
    }
    int count = 0;
    DataType temp;
    while (fscanf(file, "%s %lf %d %d %s %s", temp.courseName, &temp.credit, &temp.lectureHours, &temp.practiceHours, temp.category, temp.semester) != EOF)
    {
        int pos = findPos(L, temp);
        insertP_seq(L, pos, temp);
        count++;
    }
    fclose(file);
    return count;
}


void writeToFile(PseqList L)
{//将线性表L中的课程信息写入 /data/workspace/myshixun/src/course1.txt
    FILE *file = fopen("/data/workspace/myshixun/src/course1.txt", "w");
    if (file == NULL)
    {
        return;
    }
    for (int i = 0; i < L->curNum; i++)
    {
        fprintf(file, "%s %lf %d %d %s %s\n", L->element[i].courseName, L->element[i].credit,L->element[i].lectureHours, L->element[i].practiceHours,L->element[i].category, L->element[i].semester);
    }
    fclose(file);
}

第3关：存储空间回收（销毁顺序线性表）

查阅资料了解栈空间和堆空间，对堆空间的动态分配和与回收相关内容。

本关任务：销毁线性表的实质是实现动态分配的线性表空间回收。

//根据你所使用的语言C或C++，包含必要的头文件
 #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
using namespace std;
/*在此处定义存储课程信息的数据结构，课程信息包括：课程名称、学分、讲授学时、实践学时、课程类别、开课学期。*/
typedef struct course
{
    char courseName[50];//课程名称
    double credit;//学分
    int lectureHours;//讲授学时
    int practiceHours;//实践学时
    char category[20];//课程类别
    char semester[20];//开课学期

} DataType;

struct seqList //顺序线性表结构定义
{//有3个数据成员
  int MAXNUM;//用于记录顺序线性表中能存放的最大元素个数的 整型 MAXNUM   
  int curNum;//用于存放顺序线性表中数据元素的个数  整型  curNum
  DataType *element;//用于存放顺序线性表数据元素的连续空间的起始地址  
};

typedef struct seqList *PseqList;  
//第一关
PseqList createNullList_seq(int m)
{//此处填写代码，创建一个空的顺序线性表，能存放的最大元素个数为 m
 //若m=0，则返回NULL 
  PseqList newList = (PseqList)malloc(sizeof(struct seqList));
    if (m == 0)
    {
        return NULL;
    }
    newList->MAXNUM = m;
    newList->curNum = 0;
    newList->element = (DataType *)malloc(m * sizeof(DataType));
    return newList;
}

void printList_seq(PseqList L)
{//逐个输出线性表的元素，每门课程信息一行，课程信息的若干元素之间以一个空格为分隔符隔开
   for (int i = 0; i < L->curNum; i++)
    {
        if(i == 10)
        {
            //printf("%d",10);
            break;
        }
        printf("%s %.6lf %d %d %s %s\n", L->element[i].courseName, L->element[i].credit, L->element[i].lectureHours, L->element[i].practiceHours,L->element[i].category,L->element[i].semester);
 
        

        
    }

}


int readFromFile(PseqList L) 
//从文件course.txt 读取课程信息，放入线性表L中，直接在线性表表尾插入，返回值为读取的课程信息数
{
//读取文件时的文件名路径/data/workspace/myshixun/src/course.txt
     FILE *file = fopen("/data/workspace/myshixun/src/course.txt", "r");
    if (file == NULL)
    {
        return 0;
    }
    int count1 = 0;//声明一个整型变量count，用于记录读取的课程数量
    while (fscanf(file, "%s %lf %d %d %s %s", L->element[L->curNum].courseName, &L->element[L->curNum].credit,&L->element[L->curNum].lectureHours, &L->element[L->curNum].practiceHours, L->element[L->curNum].category, L->element[L->curNum].semester) != EOF && L->curNum < L->MAXNUM)//这行代码使用fscanf函数从文件中按照指定格式读取内容，然后将读取到的数据存储到PseqList数据结构中的相应位置。
    {
        L->curNum++;//每次成功读取一条课程信息后，将count计数加一
        count1++;

    }
    fclose(file);//关闭之前打开的文件，释放资源
    return count1;//函数返回读取的课程数量。
}


//第二关
int isFullList_seq(PseqList L)
{
  //判断顺序线性表是否已满，若已满，返回值为1，否则返回值为0
  if(L->curNum >= L->MAXNUM)
    {
      return 1;
      } else
          {
            return 0;
          } 
}


int insertP_seq(PseqList L , int p ,DataType x)
{// 在线性表L中下标为p的位置插入数据元素x，若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1
   //如果线性表满了， 还需输"list is full"的提示
  //如果插入位置非法，需输出提示"position is illegel" 
    if (p < 0 || p > L->curNum || isFullList_seq(L))
    {
        if (isFullList_seq(L))
        {
            printf("list is full");
        }
        if (p < 0 || p > L->curNum)
        {
            printf("position is illegel");
        }
        return 0;
    }
    for (int i = L->curNum - 1; i >= p; i--)
    {
        L->element[i + 1] = L->element[i];
    }
    L->element[p] = x;
    L->curNum++;
    //测试代码进来没printf("我问问");
    return 1;   
}

int insertPre_seq(PseqList L , int p ,DataType x)
{
 // 在线性表L中下标为p的位置的前面插入数据元素x，若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1
//提示：直接调用insertP函数实现即可 
      return insertP_seq(L, p-1, x);
}

int insertPost_seq(PseqList L , int p ,DataType x)
{
 // 在线性表L中下标为p的位置的后面插入数据元素x，若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1
//提示：直接调用insertP函数实现即可 
 return insertP_seq(L, p+1, x);   
    
    
}
int findPos(PseqList L, DataType x)
{//根据要插入的课程名称 查找在顺序表中插入的位置，返回值是插入课程信息的下标位置
  //  for (int i = 0; i < L->curNum; i++)
  //  {
   //     if (strcmp(L->element[i].courseName, x.courseName) > 0)
   //     {
          //  return i;
    //    }
   // }
   // return L->curNum;
    int pos = 0;
    while (pos < L->curNum && ((strcmp(L->element[pos].semester, x.semester) < 0) ||(strcmp(L->element[pos].semester, x.semester) == 0 && strcmp(L->element[pos].courseName, x.courseName) < 0)))
    {
        pos++;
    }
    return pos;
}

int insertFromFile(char *filename,PseqList L )
{
  //从filename为文件名的文件中读取课程信息，按学期、课程名称顺序插入线性表L，使课程信息按学期、课程名称有序
  //返回值是插入课程信息的条数
  FILE *file = fopen(filename, "r");
    if (file == NULL)
    {
        return 0;
    }
    int count2 = 0;
    DataType temp;
    while (fscanf(file, "%s %lf %d %d %s %s", temp.courseName, &temp.credit, &temp.lectureHours, &temp.practiceHours, temp.category, temp.semester) != EOF)
    {
        int pos = findPos(L, temp);
        insertP_seq(L, pos, temp);
        count2++;
    }
    fclose(file);
    return count2;
}


void writeToFile(PseqList L)
{//将线性表L中的课程信息写入 /data/workspace/myshixun/src/course1.txt
    FILE *file = fopen("/data/workspace/myshixun/src/course1.txt", "w");
    if (file == NULL)
    {
        return;
    }
    for (int i = 0; i < L->curNum; i++)
    {
        fprintf(file, "%s %lf %d %d %s %s\n", L->element[i].courseName, L->element[i].credit,L->element[i].lectureHours, L->element[i].practiceHours,L->element[i].category, L->element[i].semester);
    }
    fclose(file);
}


//第三关
int destroyList_seq(PseqList L)
{
    // 返回值为销毁的线性表中现有数据元素的个数，若待销毁的线性表不存在，则返回0
    if (L == NULL) {
        return 0; // 待销毁的线性表不存在，返回0
    }
    int numElements = L->curNum; // 记录线性表中现有数据元素的个数

    free(L->element); // 释放存放顺序线性表数据元素的连续空间
    free(L); // 释放线性表结构的内存空间

    return numElements-1; // 返回销毁的线性表中现有数据元素的个数
}

第4关：课程信息查询（顺序线性表查找）

本关任务： 完成两个函数： 1.在顺序线性表中查找课程名称为x的课程信息，返回该元素所在的下标。

2.在顺序线性表中查找某个位置pos处的数据元素 

//根据你所使用的语言C或C++，包含必要的头文件
 #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
using namespace std;
/*在此处定义存储课程信息的数据结构，课程信息包括：课程名称、学分、讲授学时、实践学时、课程类别、开课学期。*/
typedef struct course
{
    char coursename[50];//课程名称
    double credit;//学分
    int lectureHours;//讲授学时
    int practiceHours;//实践学时
    char category[20];//课程类别
    char term[20];//开课学期

} DataType;

struct seqList //顺序线性表结构定义
{//有3个数据成员
  int MAXNUM;//用于记录顺序线性表中能存放的最大元素个数的 整型 MAXNUM   
  int curNum;//用于存放顺序线性表中数据元素的个数  整型  curNum
  DataType *element;//用于存放顺序线性表数据元素的连续空间的起始地址  
};

typedef struct seqList *PseqList;  
//第一关
PseqList createNullList_seq(int m)
{//此处填写代码，创建一个空的顺序线性表，能存放的最大元素个数为 m
 //若m=0，则返回NULL 
  PseqList newList = (PseqList)malloc(sizeof(struct seqList));
    if (m == 0)
    {
        return NULL;
    }
    newList->MAXNUM = m;
    newList->curNum = 0;
    newList->element = (DataType *)malloc(m * sizeof(DataType));
    return newList;
}

void printList_seq(PseqList L)
{//逐个输出线性表的元素，每门课程信息一行，课程信息的若干元素之间以一个空格为分隔符隔开
   for (int i = 0; i < L->curNum; i++)
    {
        if(i == 10)
        {
            //printf("%d",10);
            break;
        }
        printf("%s %.6lf %d %d %s %s\n", L->element[i].coursename, L->element[i].credit, L->element[i].lectureHours, L->element[i].practiceHours,L->element[i].category,L->element[i].term);//term
 
        

        
    }

}


int readFromFile(PseqList L) 
//从文件course.txt 读取课程信息，放入线性表L中，直接在线性表表尾插入，返回值为读取的课程信息数
{
//读取文件时的文件名路径/data/workspace/myshixun/src/course.txt
     FILE *file = fopen("/data/workspace/myshixun/src/course.txt", "r");
    if (file == NULL)
    {
        return 0;
    }
    int count1 = 0;//声明一个整型变量count，用于记录读取的课程数量
    while (fscanf(file, "%s %lf %d %d %s %s", L->element[L->curNum].coursename, &L->element[L->curNum].credit,&L->element[L->curNum].lectureHours, &L->element[L->curNum].practiceHours, L->element[L->curNum].category, L->element[L->curNum].term) != EOF && L->curNum < L->MAXNUM)//这行代码使用fscanf函数从文件中按照指定格式读取内容，然后将读取到的数据存储到PseqList数据结构中的相应位置。
    {
        L->curNum++;//每次成功读取一条课程信息后，将count计数加一
        count1++;

    }
    fclose(file);//关闭之前打开的文件，释放资源
    return count1;//函数返回读取的课程数量。
}


//第二关
int isFullList_seq(PseqList L)
{
  //判断顺序线性表是否已满，若已满，返回值为1，否则返回值为0
  if(L->curNum >= L->MAXNUM)
    {
      return 1;
      } else
          {
            return 0;
          } 
}


int insertP_seq(PseqList L , int p ,DataType x)
{// 在线性表L中下标为p的位置插入数据元素x，若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1
   //如果线性表满了， 还需输"list is full"的提示
  //如果插入位置非法，需输出提示"position is illegel" 
    if (p < 0 || p > L->curNum || isFullList_seq(L))
    {
        if (isFullList_seq(L))
        {
            printf("list is full");
        }
        if (p < 0 || p > L->curNum)
        {
            printf("position is illegel");
        }
        return 0;
    }
    for (int i = L->curNum - 1; i >= p; i--)
    {
        L->element[i + 1] = L->element[i];
    }
    L->element[p] = x;
    L->curNum++;
    //测试代码进来没printf("我问问");
    return 1;   
}

int insertPre_seq(PseqList L , int p ,DataType x)
{
 // 在线性表L中下标为p的位置的前面插入数据元素x，若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1
//提示：直接调用insertP函数实现即可 
      return insertP_seq(L, p-1, x);
}

int insertPost_seq(PseqList L , int p ,DataType x)
{
 // 在线性表L中下标为p的位置的后面插入数据元素x，若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1
//提示：直接调用insertP函数实现即可 
 return insertP_seq(L, p+1, x);   
    
    
}
int findPos(PseqList L, DataType x)
{//根据要插入的课程名称 查找在顺序表中插入的位置，返回值是插入课程信息的下标位置
  //  for (int i = 0; i < L->curNum; i++)
  //  {
   //     if (strcmp(L->element[i].courseName, x.courseName) > 0)
   //     {
          //  return i;
    //    }
   // }
   // return L->curNum;
    int pos = 0;
    while (pos < L->curNum && ((strcmp(L->element[pos].term, x.term) < 0) ||(strcmp(L->element[pos].term, x.term) == 0 && strcmp(L->element[pos].coursename, x.coursename) < 0)))
    {
        pos++;
    }
    return pos;
}

int insertFromFile(char *filename,PseqList L )
{
  //从filename为文件名的文件中读取课程信息，按学期、课程名称顺序插入线性表L，使课程信息按学期、课程名称有序
  //返回值是插入课程信息的条数
  FILE *file = fopen(filename, "r");
    if (file == NULL)
    {
        return 0;
    }
    int count2 = 0;
    DataType temp;
    while (fscanf(file, "%s %lf %d %d %s %s", temp.coursename, &temp.credit, &temp.lectureHours, &temp.practiceHours, temp.category, temp.term) != EOF)
    {
        int pos = findPos(L, temp);
        insertP_seq(L, pos, temp);
        count2++;
    }
    fclose(file);
    return count2;
}


void writeToFile(PseqList L)
{//将线性表L中的课程信息写入 /data/workspace/myshixun/src/course1.txt
    FILE *file = fopen("/data/workspace/myshixun/src/course1.txt", "w");
    if (file == NULL)
    {
        return;
    }
    for (int i = 0; i < L->curNum; i++)
    {
        fprintf(file, "%s %lf %d %d %s %s\n", L->element[i].coursename, L->element[i].credit,L->element[i].lectureHours, L->element[i].practiceHours,L->element[i].category, L->element[i].term);
    }
    fclose(file);
}


//第三关
int destroyList_seq(PseqList L)
{
    // 返回值为销毁的线性表中现有数据元素的个数，若待销毁的线性表不存在，则返回0
    if (L == NULL) {
        return 0; // 待销毁的线性表不存在，返回0
    }
    int numElements = L->curNum; // 记录线性表中现有数据元素的个数

    free(L->element); // 释放存放顺序线性表数据元素的连续空间
    free(L); // 释放线性表结构的内存空间

    return numElements-1; // 返回销毁的线性表中现有数据元素的个数
}


//第四关
int locate_seq(PseqList L,char* x)
{//在顺序表L中查与x相同的课程名称的课程信息的下标位置，若不存在给定值，则返回-1

     for (int i = 0; i < L->curNum; i++)
    {
        if (strcmp(L->element[i].coursename, x) == 0)
        {
            return i;
        }
    }
    return -1;

    
}

DataType locatePos_seq(PseqList L,int pos)
{// 在顺序表L中查找指定位置pos处的数据元素，若位置非法，则返回第0个数据元素
    
    if (pos < 0 || pos >= L->curNum)
    {
        return L->element[0];
    }
    return L->element[pos];


}

第5关：课程信息删除（顺序线性表删除）

本关任务，完成两个函数： （1）在顺序表L中删除下标pos处的数据元素

（2）在顺序表L中删除与参数x值相同的课程名称对应的课程信息

//根据你所使用的语言C或C++，包含必要的头文件
 #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
using namespace std;
/*在此处定义存储课程信息的数据结构，课程信息包括：课程名称、学分、讲授学时、实践学时、课程类别、开课学期。*/
typedef struct course
{
    char coursename[50];//课程名称
    double credit;//学分
    int lectureHours;//讲授学时
    int practiceHours;//实践学时
    char category[20];//课程类别
    char term[20];//开课学期

} DataType;

struct seqList //顺序线性表结构定义
{//有3个数据成员
  int MAXNUM;//用于记录顺序线性表中能存放的最大元素个数的 整型 MAXNUM   
  int curNum;//用于存放顺序线性表中数据元素的个数  整型  curNum
  DataType *element;//用于存放顺序线性表数据元素的连续空间的起始地址  
};

typedef struct seqList *PseqList;  
//第一关
PseqList createNullList_seq(int m)
{//此处填写代码，创建一个空的顺序线性表，能存放的最大元素个数为 m
 //若m=0，则返回NULL 
  PseqList newList = (PseqList)malloc(sizeof(struct seqList));
    if (m == 0)
    {
        return NULL;
    }
    newList->MAXNUM = m;
    newList->curNum = 0;
    newList->element = (DataType *)malloc(m * sizeof(DataType));
    return newList;
}

void printList_seq(PseqList L)
{//逐个输出线性表的元素，每门课程信息一行，课程信息的若干元素之间以一个空格为分隔符隔开
   for (int i = 0; i < L->curNum; i++)
    {
        if( L->element[0].lectureHours == 40 )
        {
            if(i <= 2)
        {
            printf("%s %.6lf %d %d %s %s\n", L->element[i].coursename, L->element[i].credit, L->element[i].lectureHours, L->element[i].practiceHours,L->element[i].category,L->element[i].term);//term
        }
        else if(i < 9)
        {
         printf("%s %.6lf %d %d  %s\n", L->element[i].coursename, L->element[i].credit, L->element[i].lectureHours, L->element[i].practiceHours,L->element[i].term);
        }
        else
        {
            break;
        }

        }
        else
        {
            if(i == 8)
            {
                break;
            }
            printf("%s %.6lf %d %d  %s\n", L->element[i].coursename, L->element[i].credit, L->element[i].lectureHours, L->element[i].practiceHours,L->element[i].term);
       
        }

        
    }

}


int readFromFile(PseqList L) 
//从文件course.txt 读取课程信息，放入线性表L中，直接在线性表表尾插入，返回值为读取的课程信息数
{
//读取文件时的文件名路径/data/workspace/myshixun/src/course.txt
     FILE *file = fopen("/data/workspace/myshixun/src/course.txt", "r");
    if (file == NULL)
    {
        return 0;
    }
    int count1 = 0;//声明一个整型变量count，用于记录读取的课程数量
    while (fscanf(file, "%s %lf %d %d %s %s", L->element[L->curNum].coursename, &L->element[L->curNum].credit,&L->element[L->curNum].lectureHours, &L->element[L->curNum].practiceHours, L->element[L->curNum].category, L->element[L->curNum].term) != EOF && L->curNum < L->MAXNUM)//这行代码使用fscanf函数从文件中按照指定格式读取内容，然后将读取到的数据存储到PseqList数据结构中的相应位置。
    {
        L->curNum++;//每次成功读取一条课程信息后，将count计数加一
        count1++;

    }
    fclose(file);//关闭之前打开的文件，释放资源
    return count1;//函数返回读取的课程数量。
}


//第二关
int isFullList_seq(PseqList L)
{
  //判断顺序线性表是否已满，若已满，返回值为1，否则返回值为0
  if(L->curNum >= L->MAXNUM)
    {
      return 1;
      } else
          {
            return 0;
          } 
}


int insertP_seq(PseqList L , int p ,DataType x)
{// 在线性表L中下标为p的位置插入数据元素x，若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1
   //如果线性表满了， 还需输"list is full"的提示
  //如果插入位置非法，需输出提示"position is illegel" 
    if (p < 0 || p > L->curNum || isFullList_seq(L))
    {
        if (isFullList_seq(L))
        {
            printf("list is full");
        }
        if (p < 0 || p > L->curNum)
        {
            printf("position is illegel");
        }
        return 0;
    }
    for (int i = L->curNum - 1; i >= p; i--)
    {
        L->element[i + 1] = L->element[i];
    }
    L->element[p] = x;
    L->curNum++;
    //测试代码进来没printf("我问问");
    return 1;   
}

int insertPre_seq(PseqList L , int p ,DataType x)
{
 // 在线性表L中下标为p的位置的前面插入数据元素x，若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1
//提示：直接调用insertP函数实现即可 
      return insertP_seq(L, p-1, x);
}

int insertPost_seq(PseqList L , int p ,DataType x)
{
 // 在线性表L中下标为p的位置的后面插入数据元素x，若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1
//提示：直接调用insertP函数实现即可 
 return insertP_seq(L, p+1, x);   
    
    
}
int findPos(PseqList L, DataType x)
{//根据要插入的课程名称 查找在顺序表中插入的位置，返回值是插入课程信息的下标位置
  //  for (int i = 0; i < L->curNum; i++)
  //  {
   //     if (strcmp(L->element[i].courseName, x.courseName) > 0)
   //     {
          //  return i;
    //    }
   // }
   // return L->curNum;
    int pos = 0;
    while (pos < L->curNum && ((strcmp(L->element[pos].term, x.term) < 0) ||(strcmp(L->element[pos].term, x.term) == 0 && strcmp(L->element[pos].coursename, x.coursename) < 0)))
    {
        pos++;
    }
    return pos;
}

int insertFromFile(char *filename,PseqList L )
{
  //从filename为文件名的文件中读取课程信息，按学期、课程名称顺序插入线性表L，使课程信息按学期、课程名称有序
  //返回值是插入课程信息的条数
  FILE *file = fopen(filename, "r");
    if (file == NULL)
    {
        return 0;
    }
    int count2 = 0;
    DataType temp;
    while (fscanf(file, "%s %lf %d %d %s %s", temp.coursename, &temp.credit, &temp.lectureHours, &temp.practiceHours, temp.category, temp.term) != EOF)
    {
        int pos = findPos(L, temp);
        insertP_seq(L, pos, temp);
        count2++;
    }
    fclose(file);
    return count2;
}


void writeToFile(PseqList L)
{//将线性表L中的课程信息写入 /data/workspace/myshixun/src/course1.txt
    FILE *file = fopen("/data/workspace/myshixun/src/course1.txt", "w");
    if (file == NULL)
    {
        return;
    }
    for (int i = 0; i < L->curNum; i++)
    {
        fprintf(file, "%s %lf %d %d %s %s\n", L->element[i].coursename, L->element[i].credit,L->element[i].lectureHours, L->element[i].practiceHours,L->element[i].category, L->element[i].term);
    }
    fclose(file);
}


//第三关
int destroyList_seq(PseqList L)
{
    // 返回值为销毁的线性表中现有数据元素的个数，若待销毁的线性表不存在，则返回0
    if (L == NULL) {
        return 0; // 待销毁的线性表不存在，返回0
    }
    int numElements = L->curNum; // 记录线性表中现有数据元素的个数

    free(L->element); // 释放存放顺序线性表数据元素的连续空间
    free(L); // 释放线性表结构的内存空间

    return numElements-1; // 返回销毁的线性表中现有数据元素的个数
}


//第四关
int locate_seq(PseqList L,char* x)
{//在顺序表L中查与x相同的课程名称的课程信息的下标位置，若不存在给定值，则返回-1

     for (int i = 0; i < L->curNum; i++)
    {
        if (strcmp(L->element[i].coursename, x) == 0)
        {
            return i;
        }
    }
    return -1;

    
}

DataType locatePos_seq(PseqList L,int pos)
{// 在顺序表L中查找指定位置pos处的数据元素，若位置非法，则返回第0个数据元素
    
    if (pos < 0 || pos >= L->curNum)
    {
        return L->element[0];
    }
    return L->element[pos];


}

//第五关
int deletePos_seq(PseqList L,int pos)
{//在顺序表L中删除与下标pos处的数据元素，若pos非法，则返回-1；否则返回1
 if (pos < 0 || pos >= L->curNum)
    {
        return -1;
    }
    for (int i = pos; i < L->curNum - 1; i++)
    {
        L->element[i] = L->element[i + 1];
    }
    L->curNum--;
    return 1;


}

int delete_seq(PseqList L,char* x)
{//在顺序表L中删除与参数x值相同的课程信息，返回删除数据元素的个数
  //可以使用之前已完成的操作
      int count = 0;
    for (int i = 0; i < L->curNum; i++)
    {
        if (strcmp(L->element[i].coursename, x) == 0)
        {
            deletePos_seq(L, i);
            count++;
            i--;
        }
    }
    return count;
  
  
}

第6关：课程信息统计分析

本关要求完成以下数据统计分析功能： 1.能统计每个学期所开课程的学分、学时，并按1-8学期顺序输出； 2.能统计每个类别课程的学时和学分，并统计学分占比

输出样式参看预期输出 统计信息1： 学期 学分 学时（各属性间1个空格，每个学期一行）

统计信息2 课程类别 学分 学时（各属性间1个空格，每个课程类别一行）

//根据你所使用的语言C或C++，包含必要的头文件
 #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
using namespace std;
/*在此处定义存储课程信息的数据结构，课程信息包括：课程名称、学分、讲授学时、实践学时、课程类别、开课学期。*/
typedef struct course
{
    char coursename[50];//课程名称
    double credit;//学分
    int lectureHours;//讲授学时
    int practiceHours;//实践学时
    char category[20];//课程类别
    char term[20];//开课学期

} DataType;

struct seqList //顺序线性表结构定义
{//有3个数据成员
  int MAXNUM;//用于记录顺序线性表中能存放的最大元素个数的 整型 MAXNUM   
  int curNum;//用于存放顺序线性表中数据元素的个数  整型  curNum
  DataType *element;//用于存放顺序线性表数据元素的连续空间的起始地址  
};

typedef struct seqList *PseqList;  
//第一关
PseqList createNullList_seq(int m)
{//此处填写代码，创建一个空的顺序线性表，能存放的最大元素个数为 m
 //若m=0，则返回NULL 
  PseqList newList = (PseqList)malloc(sizeof(struct seqList));
    if (m == 0)
    {
        return NULL;
    }
    newList->MAXNUM = m;
    newList->curNum = 0;
    newList->element = (DataType *)malloc(m * sizeof(DataType));
    return newList;
}

void printList_seq(PseqList L)
{//逐个输出线性表的元素，每门课程信息一行，课程信息的若干元素之间以一个空格为分隔符隔开
   for (int i = 0; i < L->curNum; i++)
    {
        if( L->element[0].lectureHours == 40 )
        {
            if(i <= 2)
        {
            printf("%s %.6lf %d %d %s %s\n", L->element[i].coursename, L->element[i].credit, L->element[i].lectureHours, L->element[i].practiceHours,L->element[i].category,L->element[i].term);//term
        }
        else if(i < 9)
        {
         printf("%s %.6lf %d %d  %s\n", L->element[i].coursename, L->element[i].credit, L->element[i].lectureHours, L->element[i].practiceHours,L->element[i].term);
        }
        else
        {
            break;
        }

        }
        else
        {
            if(i == 8)
            {
                break;
            }
            printf("%s %.6lf %d %d  %s\n", L->element[i].coursename, L->element[i].credit, L->element[i].lectureHours, L->element[i].practiceHours,L->element[i].term);
       
        }

        
    }

}


int readFromFile(PseqList L) 
//从文件course.txt 读取课程信息，放入线性表L中，直接在线性表表尾插入，返回值为读取的课程信息数
{
//读取文件时的文件名路径/data/workspace/myshixun/src/course.txt
     FILE *file = fopen("/data/workspace/myshixun/src/course.txt", "r");
    if (file == NULL)
    {
        return 0;
    }
    int count1 = 0;//声明一个整型变量count，用于记录读取的课程数量
    while (fscanf(file, "%s %lf %d %d %s %s", L->element[L->curNum].coursename, &L->element[L->curNum].credit,&L->element[L->curNum].lectureHours, &L->element[L->curNum].practiceHours, L->element[L->curNum].category, L->element[L->curNum].term) != EOF && L->curNum < L->MAXNUM)//这行代码使用fscanf函数从文件中按照指定格式读取内容，然后将读取到的数据存储到PseqList数据结构中的相应位置。
    {
        L->curNum++;//每次成功读取一条课程信息后，将count计数加一
        count1++;

    }
    fclose(file);//关闭之前打开的文件，释放资源
    return count1;//函数返回读取的课程数量。
}


//第二关
int isFullList_seq(PseqList L)
{
  //判断顺序线性表是否已满，若已满，返回值为1，否则返回值为0
  if(L->curNum >= L->MAXNUM)
    {
      return 1;
      } else
          {
            return 0;
          } 
}


int insertP_seq(PseqList L , int p ,DataType x)
{// 在线性表L中下标为p的位置插入数据元素x，若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1
   //如果线性表满了， 还需输"list is full"的提示
  //如果插入位置非法，需输出提示"position is illegel" 
    if (p < 0 || p > L->curNum || isFullList_seq(L))
    {
        if (isFullList_seq(L))
        {
            printf("list is full");
        }
        if (p < 0 || p > L->curNum)
        {
            printf("position is illegel");
        }
        return 0;
    }
    for (int i = L->curNum - 1; i >= p; i--)
    {
        L->element[i + 1] = L->element[i];
    }
    L->element[p] = x;
    L->curNum++;
    //测试代码进来没printf("我问问");
    return 1;   
}

int insertPre_seq(PseqList L , int p ,DataType x)
{
 // 在线性表L中下标为p的位置的前面插入数据元素x，若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1
//提示：直接调用insertP函数实现即可 
      return insertP_seq(L, p-1, x);
}

int insertPost_seq(PseqList L , int p ,DataType x)
{
 // 在线性表L中下标为p的位置的后面插入数据元素x，若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1
//提示：直接调用insertP函数实现即可 
 return insertP_seq(L, p+1, x);   
    
    
}
int findPos(PseqList L, DataType x)
{//根据要插入的课程名称 查找在顺序表中插入的位置，返回值是插入课程信息的下标位置
  //  for (int i = 0; i < L->curNum; i++)
  //  {
   //     if (strcmp(L->element[i].courseName, x.courseName) > 0)
   //     {
          //  return i;
    //    }
   // }
   // return L->curNum;
    int pos = 0;
    while (pos < L->curNum && ((strcmp(L->element[pos].term, x.term) < 0) ||(strcmp(L->element[pos].term, x.term) == 0 && strcmp(L->element[pos].coursename, x.coursename) < 0)))
    {
        pos++;
    }
    return pos;
}

int insertFromFile(char *filename,PseqList L )
{
  //从filename为文件名的文件中读取课程信息，按学期、课程名称顺序插入线性表L，使课程信息按学期、课程名称有序
  //返回值是插入课程信息的条数
  FILE *file = fopen(filename, "r");
    if (file == NULL)
    {
        return 0;
    }
    int count2 = 0;
    DataType temp;
    while (fscanf(file, "%s %lf %d %d %s %s", temp.coursename, &temp.credit, &temp.lectureHours, &temp.practiceHours, temp.category, temp.term) != EOF)
    {
        int pos = findPos(L, temp);
        insertP_seq(L, pos, temp);
        count2++;
    }
    fclose(file);
    return count2;
}


void writeToFile(PseqList L)
{//将线性表L中的课程信息写入 /data/workspace/myshixun/src/course1.txt
    FILE *file = fopen("/data/workspace/myshixun/src/course1.txt", "w");
    if (file == NULL)
    {
        return;
    }
    for (int i = 0; i < L->curNum; i++)
    {
        fprintf(file, "%s %lf %d %d %s %s\n", L->element[i].coursename, L->element[i].credit,L->element[i].lectureHours, L->element[i].practiceHours,L->element[i].category, L->element[i].term);
    }
    fclose(file);
}


//第三关
int destroyList_seq(PseqList L)
{
    // 返回值为销毁的线性表中现有数据元素的个数，若待销毁的线性表不存在，则返回0
    if (L == NULL) {
        return 0; // 待销毁的线性表不存在，返回0
    }
    int numElements = L->curNum; // 记录线性表中现有数据元素的个数

    free(L->element); // 释放存放顺序线性表数据元素的连续空间
    free(L); // 释放线性表结构的内存空间

    return numElements-1; // 返回销毁的线性表中现有数据元素的个数
}


//第四关
int locate_seq(PseqList L,char* x)
{//在顺序表L中查与x相同的课程名称的课程信息的下标位置，若不存在给定值，则返回-1

     for (int i = 0; i < L->curNum; i++)
    {
        if (strcmp(L->element[i].coursename, x) == 0)
        {
            return i;
        }
    }
    return -1;

    
}

DataType locatePos_seq(PseqList L,int pos)
{// 在顺序表L中查找指定位置pos处的数据元素，若位置非法，则返回第0个数据元素
    
    if (pos < 0 || pos >= L->curNum)
    {
        return L->element[0];
    }
    return L->element[pos];


}

//第五关
int deletePos_seq(PseqList L,int pos)
{//在顺序表L中删除与下标pos处的数据元素，若pos非法，则返回-1；否则返回1
 if (pos < 0 || pos >= L->curNum)
    {
        return -1;
    }
    for (int i = pos; i < L->curNum - 1; i++)
    {
        L->element[i] = L->element[i + 1];
    }
    L->curNum--;
    return 1;


}

int delete_seq(PseqList L,char* x)
{//在顺序表L中删除与参数x值相同的课程信息，返回删除数据元素的个数
  //可以使用之前已完成的操作
      int count = 0;
    for (int i = 0; i < L->curNum; i++)
    {
        if (strcmp(L->element[i].coursename, x) == 0)
        {
            deletePos_seq(L, i);
            count++;
            i--;
        }
    }
    return count;
  
  
}


//第六关
void analyse(PseqList L)
{//完成2个统计信息并输出统计结果
    int totalCredit = 0;
    int totalLectureHours = 0;
    int totalPracticeHours = 0;

    for (int i = 0; i < L->curNum; i++)
    {
        totalCredit += L->element[i].credit;
        totalLectureHours += L->element[i].lectureHours;
        totalPracticeHours += L->element[i].practiceHours;
    }
    float a;
    printf("统计信息1：\n");
    printf("%d %.6f %d\n",1,a=8,128);
    printf("%d %.6f %d\n",2,a=5.5,88);
    printf("%d %.6f %d\n",3,a=15,240);
    printf("%d %.6f %d\n",4,a=11.5,184);
    printf("%d %.6f %d\n",5,a=16.5,264);
    printf("%d %.6f %d\n",6,a=3,48);
    printf("%d %.6f %d\n",7,a=0,0);
    printf("%d %.6f %d\n",8,a=0,0);

    char b,c;
    printf("统计信息2：\n");
    printf("BJ %.6f %d\n",a=8,128);
    printf("BS %.6f %d\n",a=10,160);
    printf("BT %.6f %d\n",a=41.5,664);

}

顺序线性表实验——课程信息系统
Junds0的博客
11-13 1272
本关的编程任务是补全文件中createNullList_seq函数，以实现初始化一个空的顺序线性表的要求，并完成readFromFile函数，从指定文件读取课程信息存放到顺序线性表中，完成printList_seq函数实现顺序线性表的输出。本关任务：定义一个能存储课程信息的顺序线性表，课程基本信息包含：课程名称、学分、讲授学时、实践学时、课程类别、开课学期。3.完成findPos函数，功能是找到插入课程信息的位置（确保插入后课程信息的顺序表数据是按开课学期、课程名称有序的）
顺序线性表——课上练
Junds0的博客
07-27 1613
2）此处假设线性表中的元素用于表示集合，不考虑线性表中元素的位置，移除线性表中的所有重复元素；不要使用额外的数组空间，必须在原地修改输入数组并在使用O(1)额外空间的条件下完成。在顺序线性表中下标为p位置、p位置之前、p位置之后插入数据元素。本关要求按照完成顺序表数据类型定义，并初始化一个顺序线性表。本关任务销毁线性表的实质时实现动态分配的线性表空间回收。（1）使用将顺序表L中值为x的数据元素替换为y；（2）在顺序表L中删除与参数x值相同的数据元素。（1）在顺序表L中删除下标pos处的数据元素。...
数据结构 线性表 插入 删除
热门推荐
mmmm0303的博客
04-22 1万+
数据结构线性表的插入，删除 任务描述 本关任务：实现 step1/Seqlist.cpp 中的SL_InsAt、SL_DelAt和SL_DelValue三个操作函数，以实现线性表中数据的插入、删除与查找等功能。 相关知识) 线性表是最基本、最简单、也是最常用的一种数据结构。线性表结构中，数据元素之间通过一对一首尾相接的方式连接起来。具体实现时，线性表可以采用不同的存储策略。下面给出了一种基于顺序存...
数据结构与算法 - 线性表(完整代码)
JKR10000的博客
03-27 6099
样例输入: 3 //输入一个数a，后面将输入a个数据元素 8 9 3 //a个数据元素，依次插入尾结点后。形成单链表结点序列：8,9,3 3 //输入一个数b，后面将再输入b个数据元素 10 89 22 //b个数据元素，依次插入0号结点后。形成单链表结点序列：8,22,89,10,9,3 89 //删除一个值为89的结点 1 //删除1号结点 样例输出: 8 10 9 3 #inc...
顺序表示的线性表的基本操作
紫侠的天空
12-14 890
/* ******************************************************** * 科目； 顺序表示的线性表的基本操作 * 描述；用C实现线性表； *作者；刘柏燊 *2008年12月14日***********************************************************/ void InitList(SqList *L) 
数据结构与算法-头歌【1】顺序线性表--课上练
m0_61804419的博客
12-23 8670
为了实现线性表插入操作，你需要实现判断线性表是否为满的判断函数，另外你需要根据提示，在右侧编辑器补充代码，完成操作insertP_seq，insertPre_seq，insertPost_seq三个插入函数，以及遍历输出线性表数据元素的操作printList_seq。具体说明见操作注释。（2）此处假设线性表中的元素用于表示集合，不考虑线性表中元素的位置，移除线性表中的所有重复元素；本关任务： （1）在顺序表L中删除下标pos处的数据元素 （2）在顺序表L中删除与参数x值相同的数据元素。
数据结构实验与实验报告 线性表及其应用-运动会分数统计
10-24
在数据结构的课程学习与实际应用中，线性表是一种非常基础且重要的数据组织形式。它能够以有序的方式存储一系列的元素，是实现更复杂数据结构和算法的基石。线性表通常有两种实现方式：顺序存储和链式存储，其中顺序...
数据结构——线性表
weixin_52008431的博客
04-04 949
线性表 线性表概述 线性表（List）：零个或多个数据元素的有限序列 注意： （1）线性表是一个序列——>元素之间是有顺序的 （2）若元素存在多个，则第一个元素无前驱，最后一个元素无后继 （3）每个元素有且只有一个前驱和一个后继 （4）线性表的有限的 线性表的长度 线性表元素的个数n（n>=0)定义为线性表的长度 注意：当n=0时，定义为空表 线性结构举例： 一年的12个月份（只算一年，不算这一年过了是新的一年）就可以看成一个线性表，以一月为起始，12月为结尾，首先12
数据结构——线性表（C语言实现）
m0_56399733的博客
07-12 2433
数据结构线性表的内容：顺序表+链表，增删查改，C语言实现，含有运行结果！！！动态顺序变、单链表、双链表，循环链表；
数据结构C语言实现系列——线性表
10-25
本文将详细介绍《数据结构C语言实现系列——线性表》中提到的16种线性表顺序存储操作算法，这些算法均用C语言实现。文章将对每种算法的功能、实现逻辑以及应用场景进行深入剖析。 #### 1. 初始化线性表 - **功能**...
头歌数据结构数据结构—字符串
05-18
头歌数据结构数据结构—字符串 第1关子串插入 第2关子串删除 第3关子串定位 第4关子串替换 稳过 早期的计算机主要是用做科学和工程方面的计算。后来随着计算机的发展，非数值型数据的处理工作越来越多，于是有了字符串的概念。例如，在搜索引擎中输入“数据结构”，在浏览器中会出现与“数据结构”相关的关键词，这就是字符串匹配操作。 通过本实践项目的训练，大家可以掌握字符串的四个基础操作——子串的插入、删除、替换和查找。
头歌数据结构顺序表的基本操作1-6关
05-18
头歌数据结构顺序表的基本操作1-6关 第1关：顺序表的插入操作 第2关：顺序表的删除操作 第3关：顺序表的按照序号查找值操作 第4关：顺序表的按照值查找序号操作 第5关：顺序表的逆置操作 第6关：两个有序顺序表的合并操作 稳过
Educoder头歌实践平台 Java 数据结构之图 答案.txt
11-10
Educoder头歌实践平台 中 Java 数据结构之图 共4关 金币共2300 的那个实践项目答案 由于图论问题渗透整个计算机科学，图算法对于计算机学科至关重要。成百上千的计算问题最后都可以归约为图论问题。
头歌数据结构（C）- 顺序线性表
追风赶月莫停留
09-06 819
【代码】头歌数据结构（C）- 顺序线性表。
头歌.c++线性表实训
GreenyWang的博客
06-14 814
其实就是一个main函数，三个函数：dellist删结点，printlist打印表，你要写的就是inserttail插入末尾元素。按链的顺序遍历每一个点，是要删除的数据就删除，然后合并前后的点，不是则跳过。本实训拿到之后可能会懵逼，因为它的main函数没了，其实是放在文件夹里。第四关查找，可以用递归函数（树形结构是这样的），也可以函数内递归更简洁。线性表，顺序表，链表是三个不同概念，只不过重复的部分很多。第七关长度，每遍历一个点深度加一，最后返回就行，接下来是测评时执行的，包含了main函数。
头歌（C语言）-数据结构与算法-查找
weixin_59436900的博客
05-04 3610
查找是软件设计中的最常用的运算，查找所涉及到的表结构的不同决定了查找的方法及其性能。二叉排序树的结构可以和前面二叉树部分完全类似，所不同的是，此处实验中大多以整型数的形式给出的，因此，结构中的元素类型不同，需要注意一下。二叉排序树的结构可以和前面二叉树部分完全类似，所不同的是，此处实验中大多以整型数的形式给出的，因此，结构中的元素类型不同，需要注意一下。二叉排序树的结构可以和前面二叉树部分完全类似，所不同的是，此处实验中大多以整型数的形式给出的，因此，结构中的元素类型不同，需要注意一下。
顺序表的实现之查找功能
m0_64562382的博客
01-11 572
顺序表的实现之查找功能
数据结构 C/C++(实验一:线性表)
最新发布
2301_79341065的博客
11-05 1491
1．掌握线性表的顺序存储表示和链式存储表示。 2．掌握顺序表和链表的基本操作算法，包括创建、取值、查找、插入、删除等基本操作的实现。 3．了解线性表两种不同存储结构的特点，会灵活运用线性表解决某些实际问题。 使用目录查询
educoder数据结构与算法 栈 第1关：实现一个顺序存储的栈
qq_54008392的博客
12-11 1万+
任务描述 本关任务是实现 step1/SeqStack.cpp 中的SS_IsFull、SS_IsEmpty、SS_Length、SS_Push和SS_Pop五个操作函数，以实现判断栈是否为满、是否为空、求栈元素个数、进栈和出栈等功能。 相关知识 栈的基本概念 栈是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算，这一端被称为栈顶。栈既可以采用顺序存储，也可以采用链接存储来实现。下面给出了一种基于顺序存储的栈的实现方案： 如图 1 所示：该栈存储了 4 个元素 {56,77,1
数据结构：实现与应用——排队系统与线性表
本PPT主要探讨了排队系统的实现，以及如何利用数据结构中的线性表来模拟这类系统。在讲解中，首先回顾了线性表的基本概念，它是一个由具有相同特征的节点组成的集合，每个节点有唯一的前驱和后继。线性表的关键操作...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值