线性表（数据结构）

已于 2023-04-22 11:37:29 修改
阅读量295 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 Powered by 金山文档
于 2023-02-25 23:42:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52318243/article/details/129222081
版权

一 顺序表

一 思路分析

  • 定义一个顺序表

typedef struct sqlist
{
    ElemType *elem;
    int length;
    int listsize;
}Sqlist;

  • 初始化一个顺序表

void InitList_sq(Sqlist &L){
    L.elem=(ElemType*)malloc(LIST_SIZE*sizeof(ElemType));
    if(!L.elem) exit(0);
    L.length=0;
    L.listsize=LIST_SIZE;
}

  • 顺序表的插入

int ListInsert_sq(Sqlist &L,int i,ElemType e){
    if(i<1||i> L.length+1) return 0;
    if(L.length>L.listsize){
        int *newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
        if(!newbase)exit(0);
        L.elem=newbase;
        L.listsize=L.listsize+LISTINCREMENT;
    }
    int *q=&(L.elem[i-1]);
    for(int *p=&(L.elem[L.length-1]);p>=q;p--){
        *(p+1)=*p;
    }
    *q=e;
    L.length++;
    return 1;
        
}

  • 顺序表的删除

int delete_sq(Sqlist &L,int i,ElemType &e){
     if(i<1||i>L.length)return 0;
     int *p=&(L.elem[L.length-1]);
     int *q=&(L.elem[i-1]);
     e=*q;
     for(q++;q<=p;q++){
         *(q-1)=*q;
     }
     L.length--;
     return e;
 }

  • 顺序表的定位(就是输入一个元素，返回他在顺序表中的位序，若不在返回0)

int locate_sq(Sqlist L,ElemType e){
     int i=1;
     int *p=L.elem;
     while(i<=L.length && *p++!=e)i++;
     if(i<=L.length) return i;
     else return 0;
     
 }

二 全部源码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define LIST_SIZE 100
#define LISTINCREMENT 10
typedef  int ElemType;
//定义一个顺序表 
typedef struct sqlist
{
    ElemType *elem;
    int length;
    int listsize;
}Sqlist;

//初始化顺序表
int InitList_sq(Sqlist &L){
    L.elem=(ElemType*)malloc(LIST_SIZE*sizeof(ElemType));
    if(!L.elem) exit(0);
    L.length=0;
    L.listsize=LIST_SIZE;
} 


//顺序表的插入
int ListInsert_sq(Sqlist &L,int i,ElemType e){
    if(i<1||i> L.length+1) return 0;
    if(L.length>L.listsize){
        int *newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
        if(!newbase)exit(0);
        L.elem=newbase;
        L.listsize=L.listsize+LISTINCREMENT;
    }
    int *q=&(L.elem[i-1]);
    for(int *p=&(L.elem[L.length-1]);p>=q;p--){
        *(p+1)=*p;
    }
    *q=e;
    L.length++;
    return 1;
        
}

//顺序表的删除
 int delete_sq(Sqlist &L,int i,ElemType &e){
     if(i<1||i>L.length)return 0;
     int *p=&(L.elem[L.length-1]);
     int *q=&(L.elem[i-1]);
     e=*q;
     for(q++;q<=p;q++){
         *(q-1)=*q;
     }
     L.length--;
     return e;
 }
 
 //顺序表的定位 
 int locate_sq(Sqlist L,ElemType e){
     int i=1;
     int *p=L.elem;
     while(i<=L.length && *p++!=e)i++;
     if(i<=L.length) return i;
     else return 0;
     
 }

int main(){
    int e=0 ;
    Sqlist L;
    InitList_sq(L);
    //插入数值 
    ListInsert_sq(L,1,1);
    ListInsert_sq(L,2,2);
    ListInsert_sq(L,3,3);
    for(int i=0;i<L.length;i++){
        printf("%d ",L.elem[i]);
    } 
    printf("\n");
    //删除数值 
    delete_sq(L,1,e);
    for(int i=0;i<L.length;i++){
        printf("%d ",L.elem[i]);
    }
    //定位数值
    int m=locate_sq(L,3);
    printf("\n");
    printf("%d",m);    
}

三 运行结果

二 链表

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

typedef struct  node{
    int data;
    struct node * next;    
}Lnode,*LinkList;

int createList(LinkList &L,int n){
    L=(LinkList)malloc(sizeof(Lnode));
    LinkList p;
    int data;
    L->next=NULL;
    for(int i=n;i>=1;i--){
        p=(LinkList)malloc(sizeof(Lnode));
        scanf("%d",&p->data);
        p->next=L->next;
        L->next=p;
    }
}

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

void show(LinkList L){
    LinkList q;
    q=L->next;
    while(q){
        printf("%d ",q->data);
        q=q->next;
    }
}

int add(LinkList &L,int i,int e){
    LinkList p;
    p=L;int j=0;
    while(p&&j<i-1){
        p=p->next;
        j++;
    }
    if(!p||j>i-1) return 0;
    LinkList s=(LinkList)malloc(sizeof(Lnode));;
    s->data=e;
    s->next=p->next;
    p->next=s;
    return 0; 
}

int deleteL(LinkList &L,int i,int &m){
    LinkList p;
    p=L;int j=0;
    while(p->next&&j<i-1){
    p=p->next;
    j++;
    }
    if(!p->next||j>i-1) return 0;
    m=p->next->data;
    p->next=p->next->next;
    return 0;
}

int main(){
    LinkList L;
    int e,m;
    createList(L,5);
    show(L);
    printf("\n");
    printf("%d\n",LinkLength(L));
    GetElem(L,3,e);
    printf("%d\n",e);
    add(L,2,2);
    show(L);
    printf("\n");
    deleteL(L,2,m);
    show(L);
    printf("\n");
    printf("%d\n",m);
    
}

三 实验：一次多项式的表示以及相加

  • 代码

#include<stdio.h>
#include<stdlib.h>
#define OVERFLOW -2
#define OK 1
typedef int Status;
typedef struct Lnode{
    int a;  //a表示系数 
    int b;  //b次数 
    struct Lnode* next;
}node,*LinkList;

Status createList(LinkList &L,int n){
    LinkList p,end;
    L=(LinkList)malloc(sizeof(node));
    if(!L)exit(OVERFLOW);
    L->next=NULL;
    end=L;
    for(int i=0;i<n;i++){
        p=(LinkList)malloc(sizeof(node));
        if(!p)exit(OVERFLOW);
        scanf("%d %d",&p->a,&p->b);
        p->next=NULL;
        end->next=p;
        end=p;
    }    
    return OK;
}


Status Listadd(LinkList &la,LinkList &lb,LinkList &lc){
    LinkList pa,pb,pc,pt;
    lc=pc=la;
    pa=la->next;
    pb=lb->next;
    while(pa&&pb){
        if(pa->b<pb->b){
            pc->next=pa;pc=pa;pa=pa->next;
        }
        else if(pa->b>pb->b){
            pc->next=pb;pc=pb;pb=pb->next;
        }
        else{
            pa->a=pa->a+pb->a;
            if(pa->a){
                pc->next=pa;
                pc=pa;
                pa=pa->next;
                pt=pb;
                pb=pb->next;
                free(pt);
                }
            
            else{
                pt=pa;
                pa=pa->next;
                free(pt);
                pt=pb;
                pb=pb->next;
                free(pt);
            }
        }
    }
    pc->next=NULL;
    if(pa) pc->next=pa;
    if(pb) pc->next=pb; 
    free(lb);
    return OK;
}

Status printList(LinkList L){
    L=L->next;
    printf("多项式lc:\n") ;
    while(L){
        printf("%d %d\n",L->a,L->b);
        L=L->next;
    }
    return OK;
    
}

int main(){
    LinkList la,lb,lc;
    int n,m;
    printf("输入多项式la中结点的个数：\n"); 
    scanf("%d",&n);
    createList(la,n);
    printf("输入多项式lb中结点的个数：\n"); 
    scanf("%d",&m);
    createList(lb,m);
    Listadd(la,lb,lc);
    printList(lc);
    
}

  • 演示

不是小阳
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构笔记1 线性表-顺序表示
m0_49372475的博客
03-31 1207
预定义： 一些操作： 1. 线性表的初始化（参数为引用） //下列：函数返回类型 函数名称初始化线性表 参数表（参数类型 引用参数） Status InitList_Sq(SqList &L) { //构造一个空的线性表 L.elem = New ElemType[MAXSIZE]; //动态分配L.elem的内存，类型为ElemType，个数为MAXSIZE //也可以写： //L.elem = (ElemType*)malloc(size
传说中的数据结构里的线性表
qq_40555264的博客
09-09 808
一、线性表顺序表示 InitList（&amp;L） 、LocateElem(L,x,compare())、ListInsert（&amp;L，i，e ）、ListDelete( &amp;L, i, &amp;e) 。。。。。。部分的代码，下图 为什么表尾的表达式不能是q=L.length-1; 因为顺序存储结构（实际上就是数组）中，L.el...
数据结构中的L=(List)malloc(sizeof(PtrToNode))；是什么意思
cwindyc的博客
07-11 4858
sizeo函数（https://baike.baidu.com/item/sizeof/6349467#2） 用于计算数据（包括数组、变量、类型、结构体等）所占用的内存空间，用字节数表示。在L=(List)malloc(sizeof(PtrToNode));中，sizeof是对定义的结构体PtrToNode取总字节数。 malloc函数（https://baike.baidu.com/item/malloc%E5%87%BD%E6%95%B0/8582146?fromtitle=malloc&fro
数据结构第二章 ——线性表之顺序表
weixin_56727133的博客
06-13 323
顺序表的一些基本操作
malloc函数碎碎记
惟愿一生无悔也无憾
10-02 777
一、 数据结构的时候，动态分配内存 用到了 这句话 L.elem = (ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType)); 解释： //用malloc分配一段这么LIST_INIT_SIZEsizeof(ElemType)多个字节的内存段 //Elemtype这个结构体的LIST_INIT_SIZE的乘积这么大 //它返回一个指向该内存段首字节的指针变量(viod)，然后把这个指针变量强制转换为ElemType*类型 //再把这个经转换的指针变量赋
第2章 线性表 数据结构PPT
09-18
线性表是一种基础且重要的数据结构，它由n（n≥0）个类型相同的数据元素组成，这些元素按照特定的顺序排列，形成一个有限序列。线性表的特点在于其元素之间存在一对一的关系，即除了第一个元素没有直接前驱，最后一...
线性表数据结构
04-28
线性表数据结构 线性表是一种基本的数据结构，它是一种由连续的存储单元组成的集合，每个存储单元称为元素。在C++语言中，线性表可以使用数组或链表来实现。在本文中，我们将介绍线性表的动态分配顺序存储结构和...
线性表数据结构实现
01-18
线性表是一种基础且重要的数据结构，它包含一组相同类型元素的有序集合。在这个实现中，我们关注的是链表、栈和队列这三种线性表的变体，它们都是用C++语言编写的。下面将详细介绍这三种数据结构及其在C++中的实现。...
线性表 数据结构
07-07
数据结构 线性表 用C语言构造线性表来进行相关操作
线性表基本操作（数据结构）C++
爱科比的博客
04-08 1561
#include"iostream" #include"cstdio" #include"cstring" #define list_init_size 100 #define listincrement 10 using namespace std; typedef struct{ int *elem; int length;//表示线性表的当前长度 int listsize;//表示线性表的存...
编程实现顺序表的基本操作函数
mo_chen1025的博客
05-12 6252
编程实现顺序表的基本操作函数。 (1) void InitList(SqList &L, int n) //建立一个表长为n的顺序表 (2) void ListInsert(SqList &L, int i, ElemType e) //在顺序表中第i个位置插入元素函数e (3) void ListDelete(SqList&L, int i, ElemType...
《数据结构》——顺序表伪代码
VianaKong的博客
09-22 2652
#define MAXSIZE 10000 typedef struct { ElemType *elem;//elemtype在实际使用中可以替换为int，float等,其本质可看作数组 int length; }SqList; //图书 #define MAXSIZE 10000 typedef struct { char name=[50]; char ...
数据结构-线性表-1顺序线性表
weixin_49895102的博客
03-21 1107
#include<stdio.h> /*线性表的特点：同一性、有穷性、有序性*/ //线性表的抽象数据类型：数据元素、结构关系、基本操作 //基本操作：InitList/ListLength/GetData/InsList/DelList/Locate/DestroyList/ClearList/EmptyList //增删改查+基本属性 #define MAXSIZE 100 #define ElemType char //线性表的线性存储结构（如果是空表last值是-1) type.
数据结构-顺序表（SqList）
qq_54429049的博客
10-22 8595
数据结构-顺序表的设计与实现
数据结构中的elemtype、elem是什么
热门推荐
angle1020的博客
05-02 6万+
ElemType是数据结构的书上为了说明问题而用的一个词。它是element type（“元素的类型”）的简化体。　因为数据结构是讨论抽象的数据结构和算法的，一种结构中元素的类型不一定是整型、字符型、浮点型或者用户自定义类型，为了不重复说明，使用过程中用“elemtype”代表所有可能的数据类型，简单明了的概括了整体。在算法中，除特别说明外，规定ElemType的默认是int型。elem是单词...
转——链表中LinkList L与LinkList *L的区别
weixin_30457551的博客
12-09 5555
typedef struct Node{ int elem; struct node * next; }node,*LinkList; 　　 对于LinkList L: L是指向定义的node结构体的指针,可以用->运算符来访问结构体成员,即L->elem,而(*L)就是个Node型的结构体了,可以用点运算符访问该结构体成员,即(*L).elem; 对于Link...
数据结构基础(一)--顺序表的基本操作（数据结构学习总结）
Dfse的博客
07-21 2622
顺序表的基本操作：   1.头文件  SqList.h #ifndef CSqList_1 #define CSqList_1 #define MaxSize 50 typedef struct{ //结构体 int elem[MaxSize]; int length; }SqList; bool InitList(SqList &amp;L); ...
【数据结构】malloc简易用法
小菜一枚
04-28 2620
--------------- #include #include void main() { int *pi; float *pf; pi = (int*)malloc(sizeof(int)); pf = (float*)malloc(sizeof(float)); *pi = 1024; *pf = 3.14; printf("an integer = %d, a float
DS-数据结构线性表完美版资料.ppt
最新发布
12-01
DS-数据结构线性表完美版资料.ppt

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不是小阳

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值