精华内容
下载资源
问答
  • 线性表创建(C)
    2021-05-24 02:43:28

    main.c

    #define _CRT_SECURE_NO_WARNINGS

    #include "header.h"

    #include "SqList.h"

    void main(void) {

    SqList LA;  //建立线性表

    InitList_Sq(&LA);//初始化线性表

    。。。。。。。。。。。。。。。。。//添加自己的程序代码

    while (1);

    }

    header.h

    #include #include #define TRUE 1

    #define FALSE 0

    #define OK 1

    #define ok 1

    #define ERROR 0

    #define INFEASIBLE -1

    #define OVERFLOW -2

    SqList.h

    #include "header.h"

    #define LIST_INIT_SIZE 100                                 //线性表储存空间的初始分配量

    #define LISTINCREMENT 10                               //线性表储存空间的分配增量

    typedef int ElemType;

    typedef struct {

    ElemType *elem;                                              //储存空间基址

    int length;                                                         //当前长度

    int listsize;                                                        //当前分配的存储量(以sizeof(ElemType)为单位)

    }SqList;

    int  InitList_Sq(SqList *L) {

    L->elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));

    if (!L->elem) exit(OVERFLOW);                        //储存分配失败

    L->length = 0;                                                 //空表长度为0

    L->listsize = LIST_INIT_SIZE;                          //初始储存容量

    return OK;

    }

    int ListInsert_Sq(SqList *L, int i, ElemType e) {    //在顺序线性表L中第i个位置之前插入新的元素e,

    ElemType *p, *q;                                               //i的合法值为1<=i<=ListLength_Sq(L)+1

    if (i<1 || i>L->length + 1) return ERROR;       //i值不合法

    if (L->length >= L->listsize) {                         //当前储存空间已满,增加分配

    ElemType *newbase = (ElemType *)realloc(L->elem,

    (L->listsize + LISTINCREMENT) * sizeof(ElemType));

    if (!newbase)  return  ERROR;                   //储存分配失败

    L->elem = newbase;                                         //新基址

    L->listsize += LISTINCREMENT;                      //增加存储容量

    }

    q = &(L->elem[i - 1]);                                           //q为插入位置

    for (p = &(L->elem[L->length - 1]); p >= q; --p) *(p + 1) = *p;  //插入位置及之后的元素右移

    *q = e;                                                                      //插入e

    ++L->length;                                                          //表长增1

    return OK;

    }

    更多相关内容
  • 适合c语言数据结构初学者
  • 线性表创建(最基础)

    千次阅读 2021-03-26 21:27:34
    线性表:是最基本、最简单、也是最常用的一种数据结构。 前提:在学习数据结构的时候命名不要使用拼音!这是初学者的经常犯得错误。 顺序表的创建: #include<stdio.h> #define N 10 typedef int SLDataType; ...

    线性表:是最基本、最简单、也是最常用的一种数据结构。

    前提:在学习数据结构的时候命名不要使用拼音!这是初学者的经常犯得错误。

    顺序表的创建

    #include<stdio.h>
    #define N 10
    typedef int SLDataType;
    typedef struct//创建顺序表
    {
        SLDataType array[N];
        int size;
    }SeqList;
    void SeqListInit(SeqList &L)//输入顺序表的值
    {
        int i,n;
        scanf("%d",&n);
        L.size=n;
        printf("输入数据:");
        for(i=0;i<n;i++)
        {
            scanf("%d",&L.array[i]);
        }
    }
    void SeqListDestory(SeqList L)//打印顺序表的值
    {
        int i=0;
        printf("输出数据:");
        for(i=0;i<L.size;i++)
        {
            printf("%d ",L.array[i]);
        }
    }
    int main()
    {
        SeqList L;
        SeqListInit (L);
        SeqListDestory(L);
        return 0;
    }
    

    运行结果:
    在这里插入图片描述

    单链表的创建

    #include<stdio.h>
    #include<stdlib.h>
    #define N 10
    typedef int SLTDateType;
    typedef struct Node
    {
        SLTDateType date;
        struct Node *next;
    }Node,*LinkList;
    SLTDateType LinkList_Init(LinkList &L)
    {
        L=(LinkList)malloc(sizeof(Node));
        if(L==NULL)
            exit(-1);
        L->next=NULL;
        return 1;
    }
    void LinkList_createR(LinkList L,int n)
    {
        int i;
        Node *p,*r;
        r=L;
        printf("输入%d个数据: ",n);
        for(i=0;i<n;i++)
        {
            p=(LinkList)malloc(sizeof(Node));
            scanf("%d",&p->date);
            p->next=NULL;
            r->next=p;
            r=p;
        }
    }
    void LinkList_print(LinkList L)
    {
       Node *p;
       p=L->next;
       while(p)
       {
           printf("%d ",p->date);
           p=p->next;
       }
       printf("\n");
    }
    int main()
    {
        LinkList L;
        int i;
        int n=N;
        //初始化单链表
        LinkList_Init(L);
        //
        LinkList_createR(L,N);
        //输出单链表中的元素
        printf("单链表中的元素");
        LinkList_print(L);
        return 0;
    }
    

    运行结果:
    在这里插入图片描述

    展开全文
  • 数据结构 线性表创建 查找 C语言版 这是当时做的作业
  • c语言实现空线性表创建

    千次阅读 2020-04-21 22:15:18
    PSeqList createNullList_seq(int m)/*创建空列表 */ { PSeqList palist = (PSeqList)malloc(sizeof(struct SeqList)); if(palist != NULL) { palist -> element = (int *)malloc(sizeof(int) * m); if(palist -> ...
    #include<stdio.h>
    #include<stdlib.h>
    #include<malloc.h>
    
    typedef struct SeqList * PSeqList;
    
    struct SeqList
    {
        int MAXNUM;
        int n;
        int * element;
    };
    
    PSeqList createNullList_seq(int m)/*创建空列表 */
    {
        PSeqList palist = (PSeqList)malloc(sizeof(struct SeqList));
        if(palist != NULL)
        {
            palist -> element = (int *)malloc(sizeof(int) * m);
            if(palist -> element)
            {
                palist -> MAXNUM = m;
                palist -> n = 0;
                printf("ok");
                return palist;
                
            }
            else free(palist);
        }
        printf("out of space!!\n");
        return NULL;
    
    }
    
    int main()
    {
        createNullList_seq(15);
        return 0;
    }
    
    展开全文
  • c语言实现线性表创建,插入,删除及合并的源代码。
  • 线性表创建和基本操作

    千次阅读 2021-09-14 21:58:40
    线性表是最基本、最简单、也是最常用的一种数据结构。 线性表结构中,数据元素之间通过一对一首位相接的方式连接起来。 具体实现时,线性表可 以采用不同的存储策略。 该方案将线性表存储在一片连续的空间...

    &&逻辑与 ||逻辑或

    线性表是最基本、最简单、也是最常用的一种数据结构。

    线性表结构中,数据元素之间通过一对一首位相接的方式连接起来。

    具体实现时,线性表可

    以采用不同的存储策略。

    该方案将线性表存储在一片连续的空间里,通过data,len , 和max三个属性元素。

    组织成为了一个结构:

    • data: 给出线性存储空间的起始地址;
    • max : 指明线性表存储空间最
    • len : 当前线性表里的数据元素个数。

    为了讨论简化,我们假设每个数据元素是一个整数:

    该线性表的结构定义如下:
    struct SeqList{
        T* data; //数据元素存储空间的开始地址
        int len; //线性表的当前长度
        int max; //线性表的最大长度
    };

    以上示意图中的slist是指向给结构的一个指针,只要给定slist指针,就可对线性表就行操作。

    对数据元素进行操作处理是一个数据结构的重要组成部分。线性表涉及的主要操作如下:

     SeqList*SL_Create(int max)

    • 释放线性表存储空间: 释放slist->data 指向的用于存储线性表数据元素的存储空间。该操作函数具体定义如下:

    void SL_Free(SeqList*slist)

    • 置空线性表:将当前线性表变为一个空表,实现方法是将slist->len 设置为0。该操作函数具体定义如下:

    void SL_MakeEmpty(SeqList*slist)

    • 获取线性表当前长度:获取并返回线性表的当前长度slist->len。该操作函数具体定义如下:

    int SL_Length(SeqList*slist)

    • 判断线性表是否为空:若当前线性表是空表,则返回false,否则返回true.该操作函数具体定义如下:

    BOOL SL_IsEmpty(SeqList*slist)

    • 判断线性表是否已满:若线性表达到最大长度,则返回true,否则返回false。该操作函数具体定义如下:

    BOOL SL_IsFull(SeqList*slist)

    • 返回线性表第 i 个数据元素: 返回线性表的第 i 个数据元素 slist ->data[i] 。 该操作函数具体定义如下:

    T SL_GetAt(SeqList* slist , int i)

    • 修改线性表第 i 个数据元素: 将线性表的第 i 个数据元素的值修改为 x 。 该操作函数具体定义如下:

    void SL_SetAt(SeqList*slist, int i , T x)

    • 在线性表位置 i 插入数据元素 x : 将x 插入slist->data[i] 之前。若插入失败(i>slist-len 或 i <0时, 无法插入),返回false , 否则返回true。 该操作函数具体定义如下:

    BOOL SL_InsAt(SeqList*slist , int i , T x)

    • 删除线性表位置 i 处 的数据元素: 删除线性表的 i 号数据元素。输入参数 i 范围应在 [0,slist -> len -1] 内,否则会产生不能预料的异常或错误。返回被删除的数据元素的值。该操作函数具体定义如下:

    T SL_DelAt(SeqList* slist , int i)

    • 查找线性表中第一个值为x的数据元素的位置: 找到线性表中第一个值为x的数据元素的编号。返回值-1表示没有找到,返回值>=0表示该元素位置。该操作函数具体定义如下:

    int SL_FindValue(SeqList* slist , T x)

    • 删除线性表中第一个值为x的数据元素: 删除第一个值为x的数据元素,返回该数据元素的编号。如果不存在值为x的数据元素,则返回-1. 该操作函数具体定义如下:

    int SL_DelValue(SeqList*slist , T x)

    • 打印线性表: 打印整个线性表。该操作函数具体定义如下:

    void SL_Print(SeqList*slist)

    //顺序表操作实现
    
    SeqList* SL_Create(int maxlen)
    //创建一个顺序表。
    //与SqLst_Free()配对。
    {
        SeqList*slist=(SeqList*)malloc(sizeof(SeqList));
        slist->data = (T*)malloc (sizeof(T)*maxlen);
        slist -> max =maxlen;
        slist -> len=0;
        return slist;
    }
    void SL_Free(SeqList* slist)
    //释放/删除 顺序表
    //与SqLst_Create()配对
    {
        free(slist -> data);
        free(slist);
    }
    void SL_MakeEmpty(SeqList* slist)
    //置为空表
    {
        slist -> len=0
    }
    int SL_Length(SeqList* slist)
    //获取长度。
    {
        return slist ->len;
    }
    bool SL_IsEmpty(SeqList* slist)
    //判断顺序表是否为空
    {
        return 0==slist ->len;
    }
    T SL_GetAt(SeqList* slist, int i)
    //获取顺序表slist的第i号节点数据。
    //返回第i号节点的值。
    {
        if(i<0||i>=slist->len){
            printf("SL_GetAt():location error when reading elements of the slist!\n");
            SL_Free(slist);
            exit(0);
        }
        else
            return slist->data[i];
    }
    void SL_SetAt(SeqList* slist , int i ,T x)
    //设置第i 号节点的值(对第i号结点的数据进行写)。
    {
        if (i<0||i>=slist->len){
            printf("SL_SetAt():location error when setting elements of the slist!\n");
            SL_Free(slist);
            exit(0);
        }
        else
            slist->data[i]=x;
    }

    实现一个链接存储的线性表

    #include<stdlib.h>
    #include "LinkList.h"
    // 1)
    LinkList* LL_Create()
    //创建一个链接存储的线性表,初始为空表,返回llist指针
    {
        LinkList* llist=(LinkList*)malloc(sizeof(LinkList));
        llist->front=NULL;
        llist->rear=NULL;
        llist->pre=NULL;
        llist->curr=NULL;
        llist->position=0;
        llist->len=0;
        return llist;
    }
    // 2)
    void LL_Free(LinkList* llsit)
    //释放链表的结点,然后释放llist所指向的结构
    {
        LinkNode* node=llist->front;
        LinkNode* nextnode;
        while (node){
            nextnode=node->next;
            free(node);
            node=nextnode;
        }
        free(llsit);
    }
    //3)
    void LL_MakeEmpty(LinkList* llist)
    //将当前线性表变为一个空表,因此需要释放所有结点
    {
        LinkNode* node=llist->front;
        LinkNode* nextnode;
        while(node){
            nextnode=node->next;
            free(node);
            node=nextnode;
        }
        llist->front=NULL;
        llsit->rear=NULL;
        llist->pre=NULL;
        llist->curr=NULL;
        llist->position=0;
        llsit->len=0
    }
    int LL_Length(LinkList* llist)
    //返回线性表的当前长度
    {
        return llsit->len;
    }
    //5)
    bool LL_IsEmpty(LinkList* llist)
    //若当前线性表是空表,则返回true,否则返回False
    {
        return llsit->==0;
    }
    //6)
    bool LL_SetPosition(LinkList* llist, int i)
    //设置线性表的当前位置为i号位置。
    //设置成功,则返回ture,否则返回false(线性表为空,或i不在有效的返回)
    //假设线性表当前长度len,那么i的有效范围为[0,len].
    {
        int k;
        /*链表为空、或越界*/
        if(llist->len==0 || i<0 || i>llist->len ){
            printf("LL_SetPosition():position error");
            return false;
        }
        /*寻找对应结点*/
        llist ->curr=llist->front;
        llist->pre=NULL;
        llist->position=0;
        for (k=0;k<i;k++){
            llist->posiontion++;
            llist->pre=llist->curr;
            llist->curr=(llist->curr)->next;
            }
            /*返回当前结点位置*/
            return true;
        }
    }
    //8)
    bool LL_NextPosition(LinkList* llist)
    //设置线性表的当前位置的下一个位置为当前位置。
    //设置成功,则返回true,否则返回false(线性表为空,或当前位置为表尾)
    {
        if(llist->position>=0 && lllsit->position<llist->len)
        /*若当前结点存在,则将其后设置为当前结点*/
        {
            llist->position++;
            llist->pre =llist->curr;
            llist->curr=llist->curr->next;
            return true;
        }
        else
        return false;
    }
    T LL_GetAt(LinkList* llist)
    //返回线性表的当前位置的数据元素的值
    {
        if(llist->curr==NULL)
        {
                printf("LL_GetAt():Empty list,or End of the List.\n");
                LL_Free(llist);
                exit(1);           
        }
        return llist->curr->data;
    }
    void LL_SetAt(LinkList* llist, T x)
    //将线性表的当前位置的数据元素的值修改为x
    {
        if(llist->curr==NULL)
        {
            printf("LL_SetAt():Empty list,or End of the List.\n";)
            LL_Free(llist);
            exit(1);
        }
        llist->curr->data=x;
    }
    //11)
    bool LL_InsAt(LinkList* llsit,T x)
    //在线性表的当前位置之前插入数据元素x.当前位置指针指向新数据元素结点。
    {
        LinkNode *newNode=(LinkNode*)malloc(sizeof(LinkNode));
        if (newNode==NULL) return false;
        
        newNode->data=x;
        
        if (llist->len==0){
            //在空表中插入
            newNode->next=NULL;
            llist->front = llist->rear=newNode;
        }
        //当前位置为表头;
        else if (llist ->pre==NULL)
        {
            /*在表头结点处插入*/
            newNode->next=llist->front;
            llist->front=newNode;
        }
        else{
            /*在链表的中间位置或表尾后的位置插入*/
            newNode->next=llist->curr;
            llist->pre->next=newNode;
        }
        //插入在表尾后。
        if(llist->pre==llist->rear)
            llist->rear=newNode;
            /*增加链表的大小*/
            llsit->len++;
            /*新插入的结点为当前结点*/
            llist->curr=newNode;
            return true;    
    }
    //12)
    bool LL_InsAfter(LinkList* llist , T x)
    //在线性表的当前位置之后插入数据元素x。空表允许插入。当前位置指针将指向新结点。
    //若插入失败,返回false,否则返回true.
    {
        
    }
    //13)
    bool LL_DelAt(LinkList* llist)
    //删除线性表的当前位置的数据元素结点
    //若删除失败(为空表,或当前位置为尾结点之后),则放回false,否则返回true
    {
        LinkNode *oldNode;
        /*若表为空或已到表尾之后,则给出错误提示并返回*/
        if(llist->curr==NULL)
        {
            printf("LL_DelAt():delete a node that does not exist.\n");
            return false;
        }
        oldNode =llist->curr;
        /*删除的是表头结点*/
        if(llist->pre==NULL)
        {
            llist->front=oldNode->next;
        }
        /*删除的是表中或表尾结点*/
        else if (llsit->curr!NUll){
            llist->pre->next=oldNode->next;
        }
        if(oldNode==llist->rear){
            /*删除的是表尾结点,则修改表尾指针和当前结点位置值*/
            llist->rear=llist->pre;
        }
        /*后继节点作为新的当前结点*/
        llsit->curr=odlNode->next;
        /*释放原当前结点*/
        free*(oldNode);
        /*链表大小减*/
        llist->len --;
        return true;
    }
    //14)
    bool LL_DelAfter(LinkList* llist)
    //删除线性表的当前位置的那个数据元素
    //若删除失败(为空表、或当前位置是表尾),则返回false,否则返回true
    {
        LinkNode *oldNode;
        /*若表为空或已到表尾,则给出错误提示并返回*/
        if(llist->curr==NULL||llist->curr==llist->rear)
        {
            printf("LL_DelAfter():delete a node that does not exist.\n");
            return false;
        }
        /*保存被删除结点的指针并从链表中删除该节点*/
        oldNode = llist->curr->next;
        llist->curr->next=oldNode->next;
        
        if(oldNode==llsit->rear)
            /*删除的表尾结点*/
            llist->rear=llist->curr;
        /*释放别删除结点*/
        free(oldNode);
        llist->len--;
        return true;
        }
        //15)
        int LL_FindValue(LinkList* llist,T x)
        //找到线性表中第一个值为x的数据元素的编号。
        //返回值-1表示没有找到,返回值>=0表示标号。
        {
            LinkNode* p=llist->front;
            int idx=0;
            while(p!=NULL && p->data!=x){
                idx++;
                p=p->next;
            }
            if(idx>=llist->len)return -1;
            else return idx;
        }
        //16)
        int LL_DelValue(LinkList* llist, T x)
        //删除第一个值为x的数据元素,返回该数据元素的编号。如果不存在值为x的数据元素,则返回-1
        {
            int idx=LL_FindValue(llist,x);
            if(idx>0)return -1;
            LL_SetPosition(llsit,idx);
            LL_DelAt(llist);
            return idx;
        }
        //17))
        void LL_Print(LinkList* llist)
        //打印整个线性表
        {
            LinkNode* node=llist-front;
            while(node){
                printf("%d",node->data);
                node=node->next;
            }
            printf("\n");
        }
    

    展开全文
  • c++实现线性表完整代码,内涵注释,可视化操作线性表
  • 功能应尽可能完善:所提供的功能能够满足对线性表这种数据结构的实际应用操作 若某功能可以用上述原子功能组合而成,那么这个功能尽可能不提供,即,为了使工具所提供的功能尽可能简单,因为只有简单才能保证安全...
  • 线性表创建,实现插入,删除,查询和初始化创建功能 ——以c语线性表创建,实现插入,删除,查询和初始化创建功能 ——以c语言为例#include #include //morall free函数#include #define elemType int#define ...
  • 线性表创建和操作

    2021-03-05 13:54:15
    //对顺序表的操作#include#include #include#define MAXSIZE 1000typedef char ElemType;typedef struct{ElemType data[MAXSIZE];...//初始化线性表void InitList(SqList*&L){L=(SqList*)malloc(sizeof(SqL...
  • 数据结构中,线性表是一种入门级的数据结构,线性表分为序列表和链表,在下文中爱站技术频道小编将实例详解C语言线性表的顺序与实现步骤,下面一起跟着爱站技术频道的步伐来学习吧!1.概述通常来说顺序表是在计算机...
  • 参考书籍:数据结构(C语言版)--严蔚敏(清华大学出版社) 最近在学数据结构,选用以上参考数据,书中的例子只是一个编程参考,并不能直接使用,这里我...这就要求:扩大线性表LA,将存在于线性表LB中而不存在与线性表
  • 创建一个简单的线性表

    千次阅读 2019-12-08 22:36:21
    创建链表就得有链表节点。节点里面包含节点数据即值域,另外还有指针域,这里就得定义一个结构体。 为了方便下面代码方便写,将struct node定义成Node,struct node *定义为Link。 我们操作的是无头节点的空...
  • typedef struct{ int *data; int length; }sqlist; void init_list(sqlist *l){ (*l).data=(int *)malloc(3*sizeof(int));...,这两句话的意思是不是,创建一个int型指针*data指向data,然后为data开辟动态空间?
  • //结构体的一个普通变量(用于数据结点)和一个指针变量(用于头结点) //创建链表(头插法): 传入指向链表头结点的头指针作为形参 LinkList Creat_list(LinkList head) { head = (LinkList)malloc(sizeof(LNode));...
  • "---线性表创建完毕---\n" ) ; info_s n1 = { 1 , 21 , "花木兰" } ; info_s n2 = { 2 , 21 , "凯皇" } ; info_s n3 = { 3 , 21 , "百里守约" } ; info_s n4 = { 4 , 19 , ...
  • 用C++编写线性表

    千次阅读 多人点赞 2019-10-27 22:32:54
    数据结构:用C++编写顺序表 ...采用顺序存储结构存储的线性表。 元素的追加只需要在尾部处增加一个地址,顺序表的长度增大一,把值赋给该地址。 元素的插入稍微复杂一点,要先判断插入的位置...
  • #include <stdio.h> #include <stdlib.h>//morall free函数 #include <iostream> #define elemType int #define LIST_INIT_SIZE 10 using namespace std; struct sqlist { ...}
  • 数据结构 线性表

    2012-09-04 12:28:28
    数据结构概念ppt,大学老师上课展示的,数据结构对于我们编程方面有很重要的指导作用
  • 线性表插入和删除

    2021-11-06 15:53:42
    线性表的插入操作 int insert(Vec *v,int idx,int val) { if (!v) return 0; if (idx<0||idx>v->len )return 0; if (v->len == v->size)return 0; memcpy(v->data +idx+1,v->data +idx,...
  • } /***********计算线性表的长度*******************/ int SLLenght(SLType *SL) { return(SL->ListLen);//返回顺序表的元素数量 } /*********插入结点*******************************/ int SLInsert(SLType *...
  • 线性表(顺序表的创建)

    千次阅读 2017-09-12 19:44:00
    #include "stdafx.h"#include "stdlib.h"#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量#define LISTINCREMENT 10 //线性表存储空间的分配增量#define OK 1;#define ERROR 0; typedef s...
  • c语言建立线性表 顺序储存 储存结构 初始化(建立)顺序表 查找操作 一、按值查找,找到返回对应的下标 二、按照下标返回元素 插入操作 一、在线性表尾部添加元素 二、在位置i处插入元素 三、顺序表(有序)插入,...
  • C语言创建线性表

    千次阅读 2019-09-20 22:30:55
    在VS2019中创建的,结构体里定义了默认的构造函数(不清楚这算不算C++的语法),线性表的长度是动态分配的。 Incream_List 线性表扩容函数 ListInsert 插入数据函数 ListInit 初始化时输入一批数据 ListDelete 删除...
  • 上一篇讲了线性表的定义与初始化,接下来需要了解一下线性表的一些基本操作。查找查找线性表是最基本的操作之一,比如根据序号查找元素的值,或者根据值查找该值是否在线性表中,如果在,那么序号是几等等。我们来看...
  • C/C++ code#include #include #include typedef struct Node{char name[20];float score;struct Node* next;}*LinkList;void Reverse(LinkList head){LinkList p1 = head,p2 = head->next,p3;...
  • #pragma once#ifndef _LIST_H_#define _LIST_H_#includeusing namespace std;templateclass List{public:List(int size);~List();void ClearList();bool isEmpty();...//获取线性表的长度bool GetE...
  • 线性表基本功能的实现ADT 基本功能包括: (1)建立线性表; 输入有两行,第一行是一个整数n,线性表的长度; 第二行是n和数据元素 (2)插入: 输入两个整数,即元素插入的位置... 输入创建第二个集合(线性表),

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,080
精华内容 17,632
关键字:

线性表的创建

友情链接: filepicker-2.0.5.rar