C语言,数据结构,完成顺序表的定义

C语言,数据结构,完成顺序表的定义、初始化、插入、删除、定位、合并等函数的编写,并自己独立完成顺序表的输出函数编写。要求在主函数中实现对以上操作的调用实现以下功能
定义三个顺序表La,Lb,Lc,并调用初始化函数实现三个表的初始化
调用插入函数依次往La中插入元素13579
调用插入函数依次往Lb中插入元素246810
调用输出函数输出La和Lb
调用删除函数删除La的第1个元素并输出删除后的La
由用户输入一个数,然后通过定位函数查找这个数是否在Lb中,如果在则删除这个数并输出删除后的Lb,如果不在则不做任何操作
调用合并函数将La和Lb合并成一个顺序表放到Lc,并输出合并后的Lc的元素序列

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#define Size 5
//显示日期、时间、文件信息
void xinxi()
{
 
    printf("Date : %s\n", __DATE__);
    printf("Time : %s\n", __TIME__);
    printf("File : %s\n", __FILE__);
    printf("Line : %d\n", __LINE__);
    printf("\n***以下是程序部分***\n\n");
    
}
//定义顺序表结构
typedef struct Table
{
    int *head;//类似于数组指针
    int length;//数据长度
    int size;//机构大小
}table;
//初始化顺序表结构
table initcreact()
{
    table t;
    if ((t.head = (int *)malloc(Size*sizeof(int))) == NULL)
    {
        printf("申请存储空间失败!");
            exit(1);
    }
    t.length = 0;//初始化长度为 0
    t.size = Size;//结构大小
    return t;
}
//结构赋值
table fuzhi(table t)
{
    int i;
    for (i = 0; i < t.size; i++)
    {
        t.head[i] = i + 1;
        t.length++;//长度随赋值情况增加
    }
    return t;
}
//输出结构存储情况
table prt(table t)
{
    printf("存储的数据如下:\n");
    for (int i = 0; i < t.length; i++)
        printf("%d ", t.head[i]);
    printf("\n");
    return t;
}
//插入数据
table insert(table t,int elme,int add)
{
    if (t.length == t.size)//如果数据结构已满,增加存储空间
        t.head= (int *)realloc(t.head, (t.size + 1) * sizeof(int));
    if (t.head == NULL)
    {
        printf("申请存储空间失败!\n");
        exit(1);
    }
    else t.size++;//空间大小增加
    int i = t.size;
    for (; i >= elme-1; i--)//数据循环后移
        t.head[i] = t.head[i - 1];
    t.head[elme-1] = add;//指定位置插入数据,赋值
    t.length++;//长度增加
    return t;
}
//删除指定数据
table deleter(table t, int elme)
{
    int i = elme-1;
    for (; i <= t.size; i++)
        t.head[i] = t.head[i +1];
    t.head[i] = 0;
    t.length--;
    return t;
}
//查询指定数据,返回在数据结构中的位置
int select(table t, int elme)
{
    int i;
    for (i = 0; i <= t.length; i++)
    {
        if (t.head[i] == elme)
            return i+1;
    }
    return -1;
}
//替换指定数据
table tihuan(table t, int elme, int add)
{
    int i=select(t,elme);
    
        t.head[i-1] = add;
        return t;
    
}
//主函数
int main()
{
    xinxi();
    table t = initcreact();
    t = fuzhi(t);
    t = prt(t);
    int elme;
    printf("请输入插入的位置:");
    scanf("%d", &elme);
    int add;
    printf("请输入插入数据:");
    scanf("%d", &add);
    if (elme > t.size+1 || elme < 0)
    {
        printf("输入的位置错误\n");
        exit(0);
    }
    t = insert(t, elme,add);
    t = prt(t);
    printf("请输入删除的位置:");
    scanf("%d", &elme);
    if (elme > t.size || elme < 0)
    {
        printf("输入的位置错误\n");
        exit(0);
    }
    t = deleter(t, elme);
    t = prt(t);
    printf("查找 5 的位置\n");
    elme = select(t, 5);
    printf("5 的位置是 %d\n", elme);
 
    t = prt(t);
    printf("用 55 替换 5\n");
    tihuan(t, 5, 55);
    t = prt(t);
 
    system("pause");
    return 0;
}

【数据结构(C语言)】顺序表的定义,实现初始化、创建、插入、增、删、改、查等基本操作(详细)_渡过晚枫的博客-CSDN博客_顺序表的定义和初始化 顺序表是在计算机内内存中以数组的形式保存的线性表,线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中,即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系,采用顺式存储结构的线性表通常称为顺序表。相对于链式存储结构而言,顺式存储结构显得更为简单。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。顺序表的基本运算有:初始化查找插入删除输. https://blog.csdn.net/DuFengYa/article/details/124898609?ops_request_misc=&request_id=&biz_id=102&utm_term=C%E8%AF%AD%E8%A8%80%EF%BC%8C%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%EF%BC%8C%E5%AE%8C%E6%88%90%E9%A1%BA%E5%BA%8F%E8%A1%A8%E7%9A%84%E5%AE%9A%E4%B9%89&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-0-124898609.pc_edu_default&spm=1018.2226.3001.4449

稍等,正在写

参考链接

C语言实现顺序表(数据结构)_桜キャンドル淵的博客-CSDN博客_c语言顺序表 以下是我们需要实现的顺序表的功能。以下是写在SeqList.h中的内容,我们将全部需要声明的内容放在此处pragma once#include <stdio.h>#include <assert.h>#include <stdlib.h>typedef int SLDateType;typedef struct SeqList{ SLDateType* a; size_t size;// 当前存储的数据个数 size_t c https://blog.csdn.net/weixin_62684026/article/details/124352803?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522166729324416782395348750%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=166729324416782395348750&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~rank_v31_ecpm-1-124352803-null-null.nonecase&utm_term=C%E8%AF%AD%E8%A8%80%EF%BC%8C%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%EF%BC%8C%E5%AE%8C%E6%88%90%E9%A1%BA%E5%BA%8F%E8%A1%A8%E7%9A%84%E5%AE%9A%E4%B9%89&spm=1018.2226.3001.4450

运行结果:
下面的测试结果是再输入的数5不再lb中,不做任何操作。

img

代码:

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#define MaxSize 100
typedef int ElemType;

typedef struct
{
    ElemType data[MaxSize];
    int length;
}SeqList;

//初始化
void ListInit(SeqList* L)
{
    L->length = 0;
}
//插入
int ListInsert(SeqList* L, int i, ElemType x)
{
    int j;
    if (L->length == MaxSize)
    {
        printf("顺序表已满无法插入!");
        return 0;
    }
    else if (i<1 || i>L->length + 1)
    {
        printf("插入位序不合法!\n");
        return 0;
    }
    else
    {
        //i--;  //修改1  
        for (j = L->length; j > i; j--)
            L->data[j] = L->data[j - 1];
        L->data[i - 1] = x;  //修改2  i-1
        L->length++;
        return 1;
    }
}

//显示
void ShowList(SeqList L)
{
    int i;
    for (i = 0; i < L.length; i++)
    {
        if (i < L.length - 1)
            printf("%d ", L.data[i]);
        else
            printf("%d\n", L.data[i]);
    }
}

//删除元素
int ListDelete(SeqList* L, int i, ElemType* x)
{
    int j;
    if (L->length == 0)
    {
        printf("顺序表已空无数据元素可删!\n");
        return 0;
    }
    else if (i<1 || i>L->length)
    {
        printf("删除位序不合法!\n");
        return 0;
    }
    else
    {
        i--;
        *x = L->data[i];
        for (j = i; j < L->length; j++)
            L->data[j] = L->data[j + 1]; //修改3
        L->length--;
        return 1;
    }
}
//判断元素是否在表中
int IsInList(SeqList L, ElemType x)
{
    int i;
    for (i = 0; i < L.length; i++)
    {
        if (L.data[i] == x)
            return i;
    }
    return -1; //不存在,返回-1
}

//合并
void Merge(SeqList la, SeqList lb, SeqList* lc)
{
    int i = 0, j = 0, k = 0;
    while (i < la.length && j < lb.length)
    {
        if (la.data[i] < lb.data[j])
            lc->data[k++] = la.data[i++];
        else
            lc->data[k++] = lb.data[j++];
    }
    //剩余部分插入
    while (i < la.length)
        lc->data[k++] = la.data[i++];
    while (j < lb.length)
        lc->data[k++] = lb.data[j++];
    lc->length = la.length + lb.length;
}

int main()
{
    SeqList la, lb, lc;
    int i, k, index = 0;
    ElemType e;
    //(1)初始化三个表
    ListInit(&la);
    ListInit(&lb);
    ListInit(&lc);
    //13579插入la
    for (i = 0; i < 5; i++)
        ListInsert(&la, i + 1, 2 * i + 1);
    //246810插入lb
    for (i = 1; i <= 5; i++)
        ListInsert(&lb, i, 2 * i);

    //(3)显示la lb
    printf("la元素:");
    ShowList(la);
    printf("lb元素:");
    ShowList(lb);

    //(4)删除la的第一个元素并输出la
    ListDelete(&la, 1, &e);
    printf("删除第1个元素后的la:");
    ShowList(la);

    printf("请输入一个数,查找是否在lb中,如果再,则删除并输出lb:");
    scanf("%d", &k);
    index = IsInList(lb, k);
    if (index >= 0)
    {
        ListDelete(&lb, index + 1, &e);
        ShowList(lb);
    }
    //(5)合并
    Merge(la, lb, &lc);
    printf("lc元素:");
    ShowList(lc);
    return 0;
}

希望有用
https://blog.csdn.net/DuFengYa/article/details/124898609?ops_request_misc=&request_id=&biz_id=102&utm_term=C%E8%AF%AD%E8%A8%80%EF%BC%8C%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%EF%BC%8C%E5%AE%8C%E6%88%90%E9%A1%BA%E5%BA%8F%E8%A1%A8%E7%9A%84%E5%AE%9A%E4%B9%89&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-0-124898609.pc_edu_default&spm=1018.2226.3001.4449

解答如下,刚打好的,有帮助请采纳

img


#include <stdio.h>
#define MAX 255
#define DataType int
typedef struct
{
    DataType data[MAX];
    int last;
} list;

list init_list(list L)
{
    L.last=0;
    return L;
}

list insert(list L,DataType x)
{
    int i,j,p=L.last;
    for(i=0; i<L.last; i++)
    {
        if(L.data[i]>x)
        {
            p=i;
            for(j=L.last; j>i; j--)
            {
                L.data[j]=L.data[j-1];
            }
            break;
        }
    }
    L.data[p]=x;
    L.last++;
    return L;
}

void output(list L)
{
    for(int i=0; i<L.last; i++)
    {
        printf("%d ",L.data[i]);
    }
    printf("\n");
}

list Delete(list L,int i)
{
    for(int j=i; j<L.last; j++)
    {
        L.data[j]=L.data[j+1];
    }
    L.last--;
    return L;
}

int search(list L,DataType x)
{
    for(int i=0; i<L.last; i++)
    {
        if(L.data[i]==x)
        {
            return i;
            break;
        }
    }
    return -1;
}

list merge2(list La,list Lb,list Lc)
{
    int ap=0,bp=0,cp=0;
    int n=La.last,m=Lb.last;
    for(int j=0; j<n+m; j++)
    {
        if(ap==n)
        {
            Lc.data[Lc.last++]=Lb.data[bp++];
            continue;
        }
        if(bp==m)
        {
            Lc.data[Lc.last++]=La.data[ap++];
            continue;
        }
        if(La.data[ap]<=Lb.data[bp]) Lc.data[Lc.last++]=La.data[ap++];
        else Lc.data[Lc.last++]=Lb.data[bp++];
    }
    return Lc;
}


int main()
{
    list La,Lb,Lc;
    La=init_list(La);
    Lb=init_list(Lb);
    Lc=init_list(Lc);

    La.last=0;
    La.last=0;
    La.last=0;

    La=insert(La,1);
    La=insert(La,3);
    La=insert(La,5);
    La=insert(La,7);
    La=insert(La,9);

    Lb=insert(Lb,2);
    Lb=insert(Lb,4);
    Lb=insert(Lb,6);
    Lb=insert(Lb,8);
    Lb=insert(Lb,10);

    printf("La:");
    output(La);
    printf("Lb:");
    output(Lb);

    La=Delete(La,0);
    printf("删除La的第1个元素:");
    output(La);

    int num;
    printf("输入一个数:");
    scanf("%d",&num);

    int p=search(Lb,num);
    if(p>=0)
    {
        printf("删除%d并输出删除后的Lb:",num);
        Lb=Delete(Lb,p);
        output(Lb);
    }

    Lc=merge2(La,Lb,Lc);
    printf("合并后的Lc:");
    output(Lc);

    return 0;
}