数据结构—线性表顺序存储与链式存储结构操作

最新推荐文章于 2023-04-12 21:55:21 发布
最新推荐文章于 2023-04-12 21:55:21 发布
阅读量1.4k 收藏 32
点赞数 5
分类专栏： 数据结构 文章标签： 数据结构 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63140630/article/details/127797824
版权

1.线性表顺序存储结构

1.顺序存储结构定义

typedef struct{
	ElemType data[MAXSIZE];	//数组，存储数据元素
	int length;	//线性表当前的长度 
}SqList;

2.获得元素操作


//获得元素操作 
// 初始条件：顺序线性表L已存在，1<=i<=ListLength(L)
//操作结果：用e返回L中第i个数据元素的值，注意i是位置
Status GetElem(SqList L,int i,ElemType *e){
	//首先判断是否为空表以及返回位置是否合法
	if(L.length==0||i<1||i>L.length){
		return ERROR;
	} 
	*e=L.data[i-1];
	
	return OK;
}

3.插入操作


//插入操作
//初始条件：顺序线性表L已存在,1≤i≤ListLength(L)
//操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1
Status ListInsert(SqList *L,int i,ElemType e){

	//如果顺序表满
	if(L->length==MAXSIZE){
		return ERROR;
	} 
	//插入位置不合法
	if(i<1||i>L->length+1){
		return ERROR;
	} 
	
	if(i<=L->length){
		//将要插入的位置元素后移一位 
		for(int k=L->length-1;k>=i-1;k--){
			L->data[k+1]=L->data[k];
		}
	} 
	//将新元素插入 
	L->data[i-1]=e;
	L->length++;
	
	return OK; 
}

4.删除操作

//删除操作
//初始条件：顺序线性表L已存在，1≤i≤ListLength(L)
// 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1
Status ListDelete(SqList *L,int i,ElemType *e){
	int k;
	//如果线性表为空
	if(L->length==0) {
		return ERROR;
	}
	//删除位置不正确
	if(i<1||i>L->length){
		return ERROR;
	} 
	*e = L->data[i-1];
	//如果删除的是最后一个元素，则不需要下面操作，如果不是，则需要将后面元素向前移动一位
	if(i<L->length){
		for(k=i;k<L->length;k++){
			L->data[k-1]=L->data[k];
		}
	} 
	L->length--;
	return OK;
}

5.遍历操作

//遍历操作 
//初始条件：顺序线性表L已存在 
//操作结果：依次对L的每个数据元素输出
Status ListTraverse(SqList L)
{
	int i;
    for(i=0;i<L.length;i++)
            visit(L.data[i]);
    cout<<endl; 
    return OK;
}

6.两表合并操作

//将所有的在线性表Lb中但不在La中的数据元素插入到La中
void unionL(SqList *La,SqList Lb){
	int La_len,Lb_len;
	ElemType e;
	//求两个线性表的长度 
	La_len=ListLength(*La);
	Lb_len=ListLength(Lb);
	for(int i=1;i<=Lb_len;i++){
		//取出Lb中第i个元素赋值给e 
		GetElem(Lb,i,&e);
		if(!LocateElem(*La,e)){
			//如果不存在就插入 
			ListInsert(La,++La_len,e);
		}
	}
}

7.完整代码

#include<iostream>
using namespace std;

//存储空间初始分配量 
#define MAXSIZE 20
 
#define OK 1
#define ERROR 0

//Status 是函数的类型，其值是函数结果状态代码，如OK等 
typedef int Status;
typedef int ElemType;

typedef struct{
	ElemType data[MAXSIZE];	//数组，存储数据元素
	int length;	//线性表当前的长度 
}SqList;


Status visit(ElemType c)
{
    printf("%d ",c);
    return OK;
}

//初始化顺序线性表 
Status InitList(SqList *L) 
{ 
    L->length=0;
    return OK;
}

//初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE
Status ListEmpty(SqList L)
{ 
	if(L.length==0)
		return OK;
	else
		return ERROR;
}

//初始条件：顺序线性表L已存在。操作结果：将L重置为空表 
Status ClearList(SqList *L)
{ 
    L->length=0;
    return OK;
}

// 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 
int ListLength(SqList L)
{
	return L.length;
}

//获得元素操作 
// 初始条件：顺序线性表L已存在，1<=i<=ListLength(L)
//操作结果：用e返回L中第i个数据元素的值，注意i是位置
Status GetElem(SqList L,int i,ElemType *e){
	//首先判断是否为空表以及返回位置是否合法
	if(L.length==0||i<1||i>L.length){
		return ERROR;
	} 
	*e=L.data[i-1];
	
	return OK;
} 

//插入操作
//初始条件：顺序线性表L已存在,1≤i≤ListLength(L)
//操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1
Status ListInsert(SqList *L,int i,ElemType e){

	//如果顺序表满
	if(L->length==MAXSIZE){
		return ERROR;
	} 
	//插入位置不合法
	if(i<1||i>L->length+1){
		return ERROR;
	} 
	
	if(i<=L->length){
		//将要插入的位置元素后移一位 
		for(int k=L->length-1;k>=i-1;k--){
			L->data[k+1]=L->data[k];
		}
	} 
	//将新元素插入 
	L->data[i-1]=e;
	L->length++;
	
	return OK; 
}


//删除操作
//初始条件：顺序线性表L已存在，1≤i≤ListLength(L)
// 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1
Status ListDelete(SqList *L,int i,ElemType *e){
	int k;
	//如果线性表为空
	if(L->length==0) {
		return ERROR;
	}
	//删除位置不正确
	if(i<1||i>L->length){
		return ERROR;
	} 
	*e = L->data[i-1];
	//如果删除的是最后一个元素，则不需要下面操作，如果不是，则需要将后面元素向前移动一位
	if(i<L->length){
		for(k=i;k<L->length;k++){
			L->data[k-1]=L->data[k];
		}
	} 
	L->length--;
	return OK;
} 

//遍历操作 
//初始条件：顺序线性表L已存在 
//操作结果：依次对L的每个数据元素输出
Status ListTraverse(SqList L)
{
	int i;
    for(i=0;i<L.length;i++)
            visit(L.data[i]);
    cout<<endl; 
    return OK;
}


//初始条件：顺序线性表L已存在
// 操作结果：返回L中第1个与e满足关系的数据元素的位序。
// 若这样的数据元素不存在，则返回值为0 
int LocateElem(SqList L,ElemType e)
{
    int i;
    if (L.length==0)
            return 0;
    for(i=0;i<L.length;i++)
    {
            if (L.data[i]==e)
                    break;
    }
    if(i>=L.length)
            return 0;

    return i+1;
}


//将所有的在线性表Lb中但不在La中的数据元素插入到La中
void unionL(SqList *La,SqList Lb){
	int La_len,Lb_len;
	ElemType e;
	//求两个线性表的长度 
	La_len=ListLength(*La);
	Lb_len=ListLength(Lb);
	for(int i=1;i<=Lb_len;i++){
		//取出Lb中第i个元素赋值给e 
		GetElem(Lb,i,&e);
		if(!LocateElem(*La,e)){
			//如果不存在就插入 
			ListInsert(La,++La_len,e);
		}
	}
}


int main(){
	cout<<"新建线性表L1"<<endl;
	SqList L1;
	cout<<"插入元素"<<endl; 
	for(int i=0;i<8;i++){
		//ListInsert(SqList *L,int i,ElemType e)
		//一直在表头插入元素 
		ListInsert(&L1,1,i);
	}
	
	cout<<"获取L1表的长度:"<<ListLength(L1)<<endl;
	
	cout<<"遍历线性表L1"<<endl;
	ListTraverse(L1);
	
	cout<<endl;
	
	cout<<"新建线性表L2"<<endl; 
	SqList L2;
	cout<<"插入元素"<<endl; 
	for(int i=9;i<=14;i++){
		//ListInsert(SqList *L,int i,ElemType e)
		//一直在表头插入元素 
		ListInsert(&L2,1,i);
	}
	cout<<"获取L2表的长度:"<<ListLength(L2)<<endl;
	cout<<"遍历线性表L2"<<endl;
	ListTraverse(L2);
	cout<<endl;
	
	
	//合并线性表
	cout<<"合并两个线性表"<<endl; 
	unionL(&L1,L2);
	cout<<"重新遍历L1"<<endl;
	ListTraverse(L1);
	return 0; 
	
}

2.线性表链式存储结构

1.链式存储结构定义

//线性表的单链表存储结构 
typedef struct Node{
	ElemType data;
	struct Node *next; 
}Node;

typedef struct Node *LinkList;


Status visit(ElemType c)
{
   	cout<<c<<endl;
    return OK;
}

2.读取元素

//单链表读取
//初始条件：链式线性表L已存在，1<=L<=ListLength(L)
//操作结果：用e返回L中第i个数据元素的值
Status GetElem(LinkList L,int i,ElemType *e){
	int j;
	LinkList p;	//声明一结点p
	p=L->next;	//p指向L的第一个结点
	j = 1;
	while(p&&j<i){
		p=p->next;
		++j;
	} 
	//第i个元素不存在 
	if(!p||j>i){
		return ERROR;
	}
	//取出第i个元素 
	*e=p->data;
	return OK;
}

3.插入操作

//插入操作
//初始条件：链式线性表L已存在,1≤i≤ListLength(L)，
// 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 
Status ListInsert(LinkList *L,int i,ElemType e){
	int j;
	LinkList p,s;
	p=*L;
	j=1;
	//寻找第i个结点 
	while(p&&j<i){
		p=p->next;
		++j;
	}
	if(!p||j>i){
		//第i个元素不存在
		return ERROR; 
	} 
	s = (LinkList)malloc(sizeof(Node));//生成新结点 
	s->data=e;
	s->next=p->next;	//将p的后记结点赋值给s后继 
	p->next=s;	//将s赋值给p的后继 
	
	return OK;
}

4.删除操作

//删除操作
// 初始条件：链式线性表L已存在，1≤i≤ListLength(L) 
// 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 
Status ListDelete(LinkList *L,int i,ElemType *e){
	int j;
	LinkList p,q;
	p=*L;
	j=1;
	//遍历寻找第i个元素 
	while(p->next&&j<i){
		p=p->next;
		++j;
	}
	if(!(p->next)||j>i){
		return ERROR;
	} 
	
	q=p->next;
	p->next=q->next;
	*e=q->data;
	free(q);
	
	return OK;
}

5.随机产生数，头插法建立线性表

//随机产生n个元素的值，建立带表头结点的单链线性表L(头插法）
void CreateListHead(LinkList *L,int n){
	LinkList p;
	int i;
	//初始化随机数种子 
	srand(time(0));
	*L=(LinkList)malloc(sizeof(Node));
	(*L)->next = NULL;
	for(i=0;i<n;i++){
		p=(LinkList)malloc(sizeof(Node));	//生成新结点
		p->data=rand()%100+1;
		p->next=(*L)->next;
		(*L)->next=p; //插入到表头 
		
	} 
	
}

6.随机产生数，尾插法建立线性表

// 随机产生n个元素的值，建立带表头结点的单链线性表L(尾插法）
void CreateListTail(LinkList *L,int n){
	LinkList p,r;
	int i;
	srand(time(0));
	*L=(LinkList)malloc(sizeof(Node));	//L为整个线性表 
	r=*L;	//r为指向尾部的结点
	for(i=0;i<n;i++){
		p=(Node*)malloc(sizeof(Node));
		p->data=rand()%100+1;
		r->next=p;
		r=p;
	} 
	r->next=NULL;
	
}

7.完整代码

#include<iostream>
#include "string.h"
#include "ctype.h"      
#include "stdlib.h"   
#include "math.h"  
#include "time.h"
using namespace std;


#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 20 //储空间初始分配量

typedef int Status;// Status是函数的类型,其值是函数结果状态代码，如OK等 
typedef int ElemType;// ElemType类型根据实际情况而定，这里假设为int 



//线性表的单链表存储结构 
typedef struct Node{
	ElemType data;
	struct Node *next; 
}Node;

typedef struct Node *LinkList;


Status visit(ElemType c)
{
   	cout<<c<<endl;
    return OK;
} 



// 初始化链式线性表 
Status InitList(LinkList *L) 
{ 
    *L=(LinkList)malloc(sizeof(Node)); //产生头结点,并使L指向此头结点 
    if(!(*L)) //存储分配失败
            return ERROR;
    (*L)->next=NULL; //指针域为空 

    return OK;
}

// 初始条件：链式线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE 
Status ListEmpty(LinkList L)
{ 
    if(L->next)
            return FALSE;
    else
            return TRUE;
}

//初始条件：链式线性表L已存在。操作结果：将L重置为空表 
Status ClearList(LinkList *L)
{ 
	LinkList p,q;
	p=(*L)->next;	//p指向头结点
	while(p){
		q=p->next;
		free(p);
		p=q;
	} 
	(*L)->next=NULL;
	
	return OK;
	
}

//初始条件：链式线性表L已存在。操作结果：返回L中数据元素个数 
int ListLength(LinkList L)
{
    int i=0;
    LinkList p=L->next; /* p指向第一个结点 */
    while(p)                        
    {
        i++;
        p=p->next;
    }
    return i;
}

//单链表读取
//初始条件：链式线性表L已存在，1<=L<=ListLength(L)
//操作结果：用e返回L中第i个数据元素的值
Status GetElem(LinkList L,int i,ElemType *e){
	int j;
	LinkList p;	//声明一结点p
	p=L->next;	//p指向L的第一个结点
	j = 1;
	while(p&&j<i){
		p=p->next;
		++j;
	} 
	//第i个元素不存在 
	if(!p||j>i){
		return ERROR;
	}
	//取出第i个元素 
	*e=p->data;
	return OK;
} 

//初始条件：链式线性表L已存在 
//操作结果：返回L中第1个与e满足关系的数据元素的位序。 
//若这样的数据元素不存在，则返回值为0 
int LocateElem(LinkList L,ElemType e)
{
    int i=0;
    LinkList p=L->next;
    while(p)
    {
        i++;
        if(p->data==e) /* 找到这样的数据元素 */
                return i;
        p=p->next;
    }
    return 0;
}

//插入操作
//初始条件：链式线性表L已存在,1≤i≤ListLength(L)，
// 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 
Status ListInsert(LinkList *L,int i,ElemType e){
	int j;
	LinkList p,s;
	p=*L;
	j=1;
	//寻找第i个结点 
	while(p&&j<i){
		p=p->next;
		++j;
	}
	if(!p||j>i){
		//第i个元素不存在
		return ERROR; 
	} 
	s = (LinkList)malloc(sizeof(Node));//生成新结点 
	s->data=e;
	s->next=p->next;	//将p的后记结点赋值给s后继 
	p->next=s;	//将s赋值给p的后继 
	
	return OK;
}  

//删除操作
// 初始条件：链式线性表L已存在，1≤i≤ListLength(L) 
// 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 
Status ListDelete(LinkList *L,int i,ElemType *e){
	int j;
	LinkList p,q;
	p=*L;
	j=1;
	//遍历寻找第i个元素 
	while(p->next&&j<i){
		p=p->next;
		++j;
	}
	if(!(p->next)||j>i){
		return ERROR;
	} 
	
	q=p->next;
	p->next=q->next;
	*e=q->data;
	free(q);
	
	return OK;
}


//初始条件：链式线性表L已存在 
// 操作结果：依次对L的每个数据元素输出 
Status ListTraverse(LinkList L)
{
    LinkList p=L->next;
    while(p)
    {
        visit(p->data);
        p=p->next;
    }
    cout<<endl;
    return OK;
}

//随机产生n个元素的值，建立带表头结点的单链线性表L(头插法）
void CreateListHead(LinkList *L,int n){
	LinkList p;
	int i;
	//初始化随机数种子 
	srand(time(0));
	*L=(LinkList)malloc(sizeof(Node));
	(*L)->next = NULL;
	for(i=0;i<n;i++){
		p=(LinkList)malloc(sizeof(Node));	//生成新结点
		p->data=rand()%100+1;
		p->next=(*L)->next;
		(*L)->next=p; //插入到表头 
		
	} 
	
} 

// 随机产生n个元素的值，建立带表头结点的单链线性表L(尾插法）
void CreateListTail(LinkList *L,int n){
	LinkList p,r;
	int i;
	srand(time(0));
	*L=(LinkList)malloc(sizeof(Node));	//L为整个线性表 
	r=*L;	//r为指向尾部的结点
	for(i=0;i<n;i++){
		p=(Node*)malloc(sizeof(Node));
		p->data=rand()%100+1;
		r->next=p;
		r=p;
	} 
	r->next=NULL;
	
}

int main()
{        
    LinkList L1;
    ElemType e;
    Status i;
    int j,k;
    i=InitList(&L1);
    cout<<"新建单链表L1"<<endl;
    cout<<"表头插入数据1-5"<<endl;
    for(j=1;j<=5;j++)
            i=ListInsert(&L1,1,j);
    cout<<"遍历L1："<<endl;
    ListTraverse(L1); 
    
    cout<<endl;
	cout<<"再在L1表头插入1-10"<<endl; 
    for(j=1;j<=10;j++)
            ListInsert(&L1,j,j);
    cout<<"遍历L1："<<endl;
    ListTraverse(L1); 

    GetElem(L1,5,&e);
    cout<<"L1第五个元素为"<<e<<endl;



    j=5; 
    ListDelete(&L1,j,&e);
    cout<<"删除第五个数据"<<e<<endl;
    

    printf("再次遍历L1：");
    ListTraverse(L1); 

    i=ClearList(&L1);
    cout<<"清空L1"<<endl;
	 
	 
	CreateListHead(&L1,5);
    cout<<"使用头插法整体创建L1"<<endl; 
    ListTraverse(L1); 

 	i=ClearList(&L1);
    cout<<"清空L1"<<endl;
    
    CreateListTail(&L1,5);
    cout<<"使用尾插法整体创建L1"<<endl; 
    ListTraverse(L1); 


    return 0;
}

上述完整代码均可运行成功。

彭于晏689
关注
  • 5
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
线性表的顺序存储结构和链式存储结构及二者的简单操作（C，C++混用）
qq_35593460的博客
11-12 1519
线性表的顺序存储结构和链式存储结构及二者的简单操作（C，C++混用） 一、前言： ​ 在学数据结构的时候，第一次上机实验，老师让我们实现线性表的顺序存储结构和链式存储结构及其简单操作，看着就脑阔疼。书上的代码吧，都是伪代码，照着敲出来n多报错（我们用的是清华大学出版社严蔚敏、陈文博编著的《数据结构及应用算法程序（修订版）》，书挺好的，就是有些地方不太照顾初学者。反正就是看着脑瓜子嗡嗡的，但搞懂了之后满满的都是成就感，让人又爱又恨，感兴趣的小伙伴可以看看）；上网搜前人的成果吧，无一例外都报错七八
数据结构之线性表（顺序表和单链表）
独自莫凭欗的博客
01-06 550
数据结构之线性表线性表的定义和特点三级目录 线性表的定义和特点 定义：由n个(n>=0)个数据特性相同的元素构成的有限序列被叫做线性表 特点： 存在唯一的一个被称作“”第一个的数据元素 存在唯一的一个被称作“最后一一个”的数据元素 三级目录 ...
camunda流程定义表无数据_数据结构：线性表走起！
weixin_35399893的博客
01-01 134
点击上方「蓝字」关注"程序员Bob"每天与你不见不散！每日一句，送给最珍贵的你：我爱，那个和你在一起的自己。上次对于算法有了一定的了解，这次我们继续学习数据结构，走起！可能大家对于线性表不是太了解(对于刚入门数据结构的来说)，那么你们在学习C语言时一定接触过单链表，小编在前几月也写过关于几篇单链表的文章，在完整的学习数据结构后就会发现那只不过是小皮毛啦。在数据结构中，线性表一直是公认最...
数据结构之队列（顺序队和链队）（C语言附完整代码）
m0_62795460的博客
04-12 6043
队列简称队，它是一种操作受限的线性表，其限制为仅允许在表的一端进行插入操作，而在表的另一端进行删除操作。把进行插入的一端称为队尾，把进行删除的一端称为队头或队首。向队列中插入新元素称为进队或入队，从队列中删除元素称为出队或离队。由于队列的插入和删除操作分别是在各自的一端进行的，每个元素必然按照进入的次序出队，所以又把队列称为先进先出表。采用顺序存储结构的队列称为顺序队声明顺序队//存放队中元素 int front , rear;//队首和队尾指针 } SqQueue;采用链式存储结构的队列称为链队。
数据结构之线性表
AHuRui的博客
04-25 669
文章目录线性表的顺序存储线性表的定义顺序存储的相关操作实现初始化依次对L的每个数据元素输出返回线性表L中元素的个数在L中第i个位置之前插入新的数据元素e，L的长度加1删除L的第i个数据元素，并用e返回其值返回L中第1个与e满足关系的数据元素的位序。返回指定位置的值将L重置为空表将所有的在线性表Lb中但不在La中的数据元素插入到La中顺序存储的代码实现样例测试输出顺序存储的优缺点 线性表的顺序存储 这里是数据结构个人学习的笔记记录，如有问题欢迎指正说明 线性表的定义 线性表的顺序存储结构，指的就是用一段
关于线性表的顺序存储和链式存储结构的实验报告
06-15
该文档饱含了数据结构课程中关于线性表的十二个基本操作的实现。对于不同的线性表的存储结构，利用C语言分别实现相应的算法
dm02_线性表顺序存储设计与实现.zip_数据结构 线性表
09-21
总的来说，这个压缩包中的代码提供了线性表顺序存储的一个基础实现，是学习和理解数据结构及算法的好例子。通过阅读和分析这段代码，你可以深入理解线性表的概念，以及如何用C语言高效地实现其基本操作。
数据结构-线性表的链式存储
最新发布
09-17
线性表的链式存储是数据结构课程中的核心概念之一，它的主要特点是通过链接而非内存位置连续来组织数据。 链式存储与顺序存储是线性表的两种基本实现方式。顺序存储（如数组）要求所有元素在内存中是连续存放的，而...
算法与数据结构（一）线性表的顺序存储与链式存储（Swift版） 定义线性表节点的结构.pdf
04-18
本文主要介绍了算法与数据结构的相关知识，特别是线性表的顺序存储和链式存储结构。在 Swift 语言的环境下，我们将深入探讨数据结构的实现细节。 首先，数据结构是编程的基础，算法与数据结构的关系可以用公式表示...
数据结构线性表的顺序存储结构
05-03
实验 二 基于链式存储结构 实现线性表的基本的 常见的运算 提示： ⑴ 提供一个实现功能的演示系统 ⑵ 具体物理结构和数据元素类型自行选定 ⑶ 线性表数据可以使用磁盘文件永久保存
【线性表一：】两种存储结构的代码实现：顺序存储和链式存储
u010800530的专栏
10-27 2782
第一个：顺序表:(未用ElemType ,全部设为int类型) #include #include #define MAX 100 #define ERROR 0 #define TRUE 1   typedef struct {     intelem[MAX];     int last; }SeqList;   void InitList(SeqList *L,
数据结构线：性表—顺序存储、链式存储各操作的实现
努力敲代码
06-30 682
实验要求: 实现顺序表和链表的建立、取元素、修改元素、插入、删除等顺序表的基本操作。 设计要求:首先设计一个含有多个菜单项的主菜单程序，然后再为这些菜单项配上相应的功能。基本操作：1.依次从键盘读入数据，建立顺序表和链表；2.求顺序表的长度；3.根据指定条件能获取元素；4.实现在指定位置插入和删除元素的功能 程序运行后创建顺序表和链表，之后给出9个菜单项的内容和输入提示...
线性表的顺序存储结构及基本操作
cai_niaocainiao的博客
10-03 4645
学习书籍《大话数据结构》，自学完后，总结一下，以后也好复习 ，欢迎互相交流。 线性表的基本操作功能如下： InitList(*L):          初始化操作，建立一个空的线性表L ListEmpty(L):      若线性表为空，返回true,否则返回false ClearList(*L):      将线性表清空 GetElem(L,i,*e) : 将线性表L中的第i个位置元...
线性表的顺序存储结构的基本操作
m0_63882760的博客
04-25 1873
1线性表的定义 线性表是具有相同特性的数据元素的一个有限序列 a1（线性起点）,a2,a3......an（线性终点）n为元素总个数（n=0时为空表） 除开第一个元素或最后一个元素外都有一个直接前驱与直接后继。 2.线性表的顺序表示和实现 线性表的顺序表示又称为顺序存储结构或顺序映像 顺序存储定义：把逻辑上相邻的数据元素存储在物理上相邻的存储单元中的存储结构 3.顺序表的基本操作及完整代码 a.顺序表的定义 //创建一个线性表 #define MAXSIZE 10 typedef stru
数据结构代码
qq_44622401的博客
10-18 1009
1.线性表 1.顺序表 typedef struct{ int data[maxSize]; int length; }Sqlist; 2.单链表 typedef struct LNode{ int data; struct DLNode *next; }LNode; 3.双链表 typedef struct DLNode{ int data; struct DLNode *prior; struct DLNode *next; }DLNode; 2.栈和队列 1.顺序栈 int st
线性表之顺序存储结构与链式存储结构 及 应用
踩踩踩从踩的博客
06-22 3862
前言 我们常用的线性基本是顺序存储结构和链式存储结构表示，是最基本、最简单、也是最常用的一种数据结构；一个线性表是由n个相同特性的数据的有限序列；比如java中的数组 ，链表；所以研究这两种结构是非常必要的。
【线性表】顺序存储、链式存储的实现及操作
innovatethinking Blog
09-24 3031
一、线性表的定义：(1)概念定义：用数据元素的有限序列表示叫做线性表；线性表中数据元素的类型可以为简单类型，也可以为复杂类型。许多实际应用问题所涉的基本操作有很大相似性，不应为每个具体应用单独编写一个程序。从具体应用中抽象出共性的逻辑结构和基本操作（抽象数据类型），然后实现其存储结构和基本操作。(2)类型定义：首先抽象出ADT List表的结构，在C/C++中一般都是采用struct来实现的。基本操
链表及代码
ZHYFXY的博客
03-23 805
一、线性表的链式存储结构 前面所讲的线性表的顺序存储结构是有缺点的，最大的缺点就是插入和删除时需要移动大量的元素，这显然就需要耗费大量时间。 仔细考虑一下产生该问题的原因，在于相邻元素的存储位置也具有邻居关系，它们在内存中是紧挨着的，没有空隙，自然也没有空位进行介入，而删除后留下的空隙自然也需要弥补。 为了解决上述问题，我们打破常规，不再让相邻元素在内存中紧挨着，而是上一个元素留存下一个元素...
线性表的顺序存储与链式存储(单链表)及操作代码实现
z_h666的博客
08-06 1066
线性表的顺序存储和链式存储及其相关操作实现 线性表的顺序存储 顺序存储的特点 以物理位置相邻表示逻辑关系 顺序存储的优缺点 优点: 1.存储密度大（本身所占存储容量/节点结构所占存储容量）    2.可以随机存取 缺点:1.插入和删除需要移动大量元素    2.浪费空间（需要一片连续的存储空间）    3.属于自由存储形式，数据元素不能自由扩充 线性表顺序存储的代码实现及相关操作解释（C++） #include<bits/stdc++.h> using namespace std; #defin

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值