• 线性表创建(C)
2021-05-24 02:43:28

main.c

#define _CRT_SECURE_NO_WARNINGS

#include "SqList.h"

void main(void) {

SqList LA;  //建立线性表

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

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

while (1);

}

#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

#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语言数据结构初学者
• 线性表：是最基本、最简单、也是最常用的一种数据结构。 前提：在学习数据结构的时候命名不要使用拼音！这是初学者的经常犯得错误。 顺序表的创建： #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;
{
if(L==NULL)
exit(-1);
L->next=NULL;
return 1;
}
{
int i;
Node *p,*r;
r=L;
printf("输入%d个数据: ",n);
for(i=0;i<n;i++)
{
scanf("%d",&p->date);
p->next=NULL;
r->next=p;
r=p;
}
}
{
Node *p;
p=L->next;
while(p)
{
printf("%d ",p->date);
p=p->next;
}
printf("\n");
}
int main()
{
int i;
int n=N;
//初始化单链表
//
//输出单链表中的元素
printf("单链表中的元素");
return 0;
}


运行结果：

展开全文
• 数据结构 线性表创建 查找 C语言版 这是当时做的作业
• 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语言实现线性表创建，插入，删除及合并的源代码。
• 线性表是最基本、最简单、也是最常用的一种数据结构。 线性表结构中，数据元素之间通过一对一首位相接的方式连接起来。 具体实现时，线性表可 以采用不同的存储策略。 该方案将线性表存储在一片连续的空间...

&&逻辑与 ||逻辑或

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

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

具体实现时，线性表可

以采用不同的存储策略。

该方案将线性表存储在一片连续的空间里，通过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>
// 1)
//创建一个链接存储的线性表,初始为空表，返回llist指针
{
llist->front=NULL;
llist->rear=NULL;
llist->pre=NULL;
llist->curr=NULL;
llist->position=0;
llist->len=0;
return llist;
}
// 2)
//释放链表的结点，然后释放llist所指向的结构
{
while (node){
nextnode=node->next;
free(node);
node=nextnode;
}
free(llsit);
}
//3)
//将当前线性表变为一个空表，因此需要释放所有结点
{
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
}
//返回线性表的当前长度
{
return llsit->len;
}
//5)
//若当前线性表是空表，则返回true，否则返回False
{
return llsit->==0;
}
//6)
//设置线性表的当前位置为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)
//设置线性表的当前位置的下一个位置为当前位置。
//设置成功，则返回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;
}
//返回线性表的当前位置的数据元素的值
{
if(llist->curr==NULL)
{
printf("LL_GetAt():Empty list,or End of the List.\n");
LL_Free(llist);
exit(1);
}
return llist->curr->data;
}
//将线性表的当前位置的数据元素的值修改为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)
//在线性表的当前位置之前插入数据元素x.当前位置指针指向新数据元素结点。
{
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)
//删除线性表的当前位置的数据元素结点
//若删除失败（为空表，或当前位置为尾结点之后），则放回false，否则返回true
{
/*若表为空或已到表尾之后，则给出错误提示并返回*/
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)
//删除线性表的当前位置的那个数据元素
//若删除失败（为空表、或当前位置是表尾），则返回false，否则返回true
{
/*若表为空或已到表尾，则给出错误提示并返回*/
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)
//找到线性表中第一个值为x的数据元素的编号。
//返回值-1表示没有找到，返回值>=0表示标号。
{
int idx=0;
while(p!=NULL && p->data!=x){
idx++;
p=p->next;
}
if(idx>=llist->len)return -1;
else return idx;
}
//16)
//删除第一个值为x的数据元素，返回该数据元素的编号。如果不存在值为x的数据元素，则返回-1
{
int idx=LL_FindValue(llist,x);
if(idx>0)return -1;
LL_SetPosition(llsit,idx);
LL_DelAt(llist);
return idx;
}
//17))
//打印整个线性表
{
while(node){
printf("%d",node->data);
node=node->next;
}
printf("\n");
}


展开全文
• c++实现线性表完整代码，内涵注释，可视化操作线性表
• 功能应尽可能完善：所提供的功能能够满足对线性表这种数据结构的实际应用操作 若某功能可以用上述原子功能组合而成，那么这个功能尽可能不提供，即，为了使工具所提供的功能尽可能简单，因为只有简单才能保证安全...
• 线性表创建，实现插入，删除，查询和初始化创建功能 ——以c语线性表创建，实现插入，删除，查询和初始化创建功能 ——以c语言为例#include #include //morall free函数#include #define elemType int#define ...
• //对顺序表的操作#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中而不存在与线性表
• 创建链表就得有链表节点。节点里面包含节点数据即值域，另外还有指针域，这里就得定义一个结构体。 为了方便下面代码方便写，将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开辟动态空间？
• "---线性表创建完毕---\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 { ...}
• 数据结构概念ppt，大学老师上课展示的，数据结构对于我们编程方面有很重要的指导作用
• 线性表的插入操作 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 *...
• #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 删除...
• 上一篇讲了线性表的定义与初始化，接下来需要了解一下线性表的一些基本操作。查找查找线性表是最基本的操作之一，比如根据序号查找元素的值，或者根据值查找该值是否在线性表中，如果在，那么序号是几等等。我们来看...
• #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）插入： 输入两个整数，即元素插入的位置... 输入创建第二个集合（线性表），

...