【数据结构】学习day 1.1线性表中的顺序表

最新推荐文章于 2024-10-25 18:01:58 发布
最新推荐文章于 2024-10-25 18:01:58 发布
阅读量1k 收藏 16
点赞数 11
分类专栏： 数据结构 文章标签： 数据结构 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62883956/article/details/140512399
版权

1  "&"区别（c++）

#include<stdio.h>
void test(int x)
{
    x=2024;
    printf("in test x=%d\n",x);
}
int main()
{
    int x=1;
    printf("before test x=%d\n",x);
    test(x);
    printf("after test x=%d\n",x);
    return 0;
}

before test x=1
in test x=2024
after test x=1

(没有带回参数的结果)

#include<stdio.h>
void test(int &x)
{
    x=2024;
    printf("in test x=%d\n",x);
}
int main()
{
    int x=1;
    printf("before test x=%d\n",x);
    test(x);
    printf("after test x=%d\n",x);
    return 0;
}

before test x=1
in test x=2024
after test x=2024

(带回了参数的修改结果)

2  初始化顺序表（静态分配）（c++）

#include<stdio.h>
#define MaxSize 10//定义最大长度

typedef struct
{
    int data[MaxSize];//用静态数组存放数据元素
    int length;//顺序表的当前长度
}SqList;//顺序表的类型定义

void InitList(SqList &L)//初始化一个顺序表
{
    for(int i=0;i<MaxSize;i++)
        L.data[i]=0;//将所有数据元素设置为0
    L.length=0;//顺序表初始长度为0
}

int main()
{
    SqList L;//声明一个顺序表
    InitList(L);//初始化顺序表
    for(int i=0;i<MaxSize;i++)
        printf("data[%d]为%d\n",i,L.data[i]);//打印顺序表每个元素
    return 0;
}

data[0]为0
data[1]为0
data[2]为0
data[3]为0
data[4]为0
data[5]为0
data[6]为0
data[7]为0
data[8]为0
data[9]为0

3  动态分配顺序表

#include<stdlib.h>//malloc,free函数的头文件
#define InitSize 10//定义最大长度



typedef struct
{
    int *data;//指示动态分配数组的指针
    int MaxSize;//顺序表的最大容量
    int length;//顺序表的当前长度
}SeqList;//顺序表的类型定义



void InitList(SeqList (&L))//初始化一个顺序表
{
    L.data=(int *)malloc(InitSize*sizeof(int));//用malloc函数申请一片连续的存储空间
    L.length=0;//顺序表初始长度为0
    L.MaxSize=InitSize;//最大长度设置为宏定义的值
}



void IncreaseSize(SeqList (&L),int len)//增加动态数组的长度，给L增加len长度
{
    int *p=L.data;
    L.data=(int *)malloc((InitSize+len)*sizeof(int));//扩大空间
    for(int i=0;i<L.length;i++)
        L.data[i]=p[i];//将数据复制到新区域
    L.MaxSize=L.MaxSize+len;//顺序表最大长度增加
    free(p);//释放原来内存空间
}



int main()
{
    SeqList L;//声明一个顺序表
    InitList(L);//初始化顺序表
    //  往顺序表中插入元素
    IncreaseSize(L,5);//增加长度
    return 0;
}

举例 ：

#include<stdio.h>
#include<stdlib.h>//malloc,free函数的头文件
#define InitSize 5//定义最大长度
typedef struct
{
	int *data;//指示动态分配数组的指针
    int MaxSize;//顺序表的最大容量
    int length;//顺序表的当前长度
}SeqList;//顺序表的类型定义
void InitList(SeqList (&L))//初始化一个顺序表
{
    L.data=(int *)malloc(InitSize*sizeof(int));//用malloc函数申请一片连续的存储空间
    L.length=0;//顺序表初始长度为0
    L.MaxSize=InitSize;//最大长度设置为宏定义的值
}
void IncreaseSize(SeqList (&L),int len)//增加动态数组的长度，给L增加len长度
{
    int *p=L.data;
    L.data=(int *)malloc((InitSize+len)*sizeof(int));//扩大空间
    for(int i=0;i<L.length;i++)
        L.data[i]=p[i];//将数据复制到新区域
    L.MaxSize=L.MaxSize+len;//顺序表最大长度增加
    free(p);//释放原来内存空间
}
int main()
{
    SeqList L;//声明一个顺序表
    InitList(L);//初始化顺序表
	printf("增加长度前的顺序表\n");
	for(int i=0;i<InitSize;i++)
	{
		L.data[i]=i;
		printf("data[%d]为%d\n",i,L.data[i]);//打印顺序表每个元素
		L.length++;
	}
    IncreaseSize(L,5);//增加长度
	printf("增加长度后的顺序表\n");
	for(int t=0;t<L.MaxSize;t++)
	{
		L.data[t]=t;
		printf("data[%d]为%d\n",t,L.data[t]);//打印顺序表每个元素
		L.length++;
	}
    return 0;
}

 增加长度前的顺序表
data[0]为0
data[1]为1
data[2]为2
data[3]为3
data[4]为4
增加长度后的顺序表
data[0]为0
data[1]为1
data[2]为2
data[3]为3
data[4]为4
data[5]为5
data[6]为6
data[7]为7
data[8]为8
data[9]为9

4   顺序表的插入

#include<stdio.h>
#define MaxSize 10//定义最大长度



typedef struct{
    int data[MaxSize];//用静态数组存放数据元素
    int length;//顺序表的当前长度
}SqList;//顺序表的类型定义



void InitList(SqList &L)//初始化一个顺序表
{
    for(int i=0;i<MaxSize;i++)
        L.data[i]=0;//将所有数据元素设置初始值
    L.length=0;//顺序表初始长度为0
}



bool ListInsert(SqList &L,int i,int e)//在L的位置i插入元素e
{
    if(i<1||i>L.length+1)
        return false;//判断i的范围是否有效
    if(L.length>=MaxSize)
        return false;//当前存储空间已满，不能插入
    for(int j=L.length;j>=i;j--)
        L.data[j]=L.data[j-1];//将第i个元素及之后的元素后移
    L.data[i-1]=e;//位置i放入e
    L.length++;//长度+1
    return true;
}



int main()
{
    SqList L;//声明
    InitList(L);//初始化
    //...插入元素
    ListInsert(L,3,9);//插入
    return 0;
}

举例：

#include<stdio.h>
#define MaxSize 10//定义最大长度
typedef struct
{
	int data[MaxSize];//用静态数组存放数据元素
	int length;//顺序表的当前长度
}SqList;//顺序表的类型定义
void InitList(SqList &L)//初始化一个顺序表
{
	for(int i=0;i<MaxSize;i++)
		L.data[i]=0;//将所有数据元素设置为0
	L.length=0;//顺序表初始长度为0
}
bool ListInsert(SqList &L,int i,int e)//在L的位置i插入元素e
{
	if(i<1||i>L.length+1)
	return false;//判断i的范围是否有效
	if(L.length>=MaxSize)
	return false;//当前存储空间已满，不能插入
	for(int j=L.length;j>=i;j--)
	L.data[j]=L.data[j-1];//将第i个元素及之后的元素后移
	L.data[i-1]=e;//位置i放入e
	L.length++;//长度+1
	return true;
}
int main()
{
	SqList L;//声明一个顺序表
	InitList(L);//初始化顺序表
	printf("插入元素前的顺序表\n");
	for(int t=0;t<6;t++)
	{
		L.data[t]=t;
		printf("data[%d]为%d\n",t,L.data[t]);//打印顺序表每个元素
		L.length++;
	}
	ListInsert(L,3,9);//插入
	printf("插入元素后的顺序表\n");
	for(int i=0;i<L.length;i++)
	{
		printf("data[%d]为%d\n",i,L.data[i]);//打印顺序表每个元素
	}
	return 0;
}

插入元素前的顺序表
data[0]为0
data[1]为1
data[2]为2
data[3]为3
data[4]为4
data[5]为5
插入元素后的顺序表
data[0]为0
data[1]为1
data[2]为9
data[3]为2
data[4]为3
data[5]为4
data[6]为5

5  顺序表的删除

bool ListDelete(SqList &L,int i,int &e)//删除i并且返回e的值
{
	if(i<1||i>L.length)
		return false;//判断i的范围是否有效
	e=L.data[i-1];//将被删除的元素赋值给e
	for(int j=i;j<L.length;j++)
		L.data[j-1]=L.data[j];//将第i个元素之后的元素前移
	L.length--;//长度-1
	return true;
}

举例：

#include<stdio.h>
#define MaxSize 10//定义最大长度
typedef struct
{
	int data[MaxSize];//用静态数组存放数据元素
	int length;//顺序表的当前长度
}SqList;//顺序表的类型定义
void InitList(SqList &L)//初始化一个顺序表
{
	for(int i=0;i<MaxSize;i++)
		L.data[i]=0;//将所有数据元素设置为0
	L.length=0;//顺序表初始长度为0
}
bool ListDelete(SqList &L,int i,int &e)//删除i并且返回e的值
{
	if(i<1||i>L.length)
		return false;//判断i的范围是否有效
	e=L.data[i-1];//将被删除的元素赋值给e
	for(int j=i;j<L.length;j++)
		L.data[j-1]=L.data[j];//将第i个元素之后的元素前移
	L.length--;//长度-1
	return true;
}
int main()
{
	int e;
	SqList L;//声明一个顺序表
	InitList(L);//初始化顺序表
	printf("开始的顺序表\n");
	for(int t=0;t<MaxSize;t++)
	{
		L.data[t]=t;
		printf("data[%d]为%d\n",t,L.data[t]);//打印顺序表每个元素
		L.length++;
	}
	if(ListDelete(L,5,e))//删除
	{
		printf("删除了第5个元素，为%d\n",e);
		printf("删除后的顺序表\n");
		for(int i=0;i<L.length;i++)
		{
			printf("data[%d]为%d\n",i,L.data[i]);
		}
	}
	return 0;
}

开始的顺序表
data[0]为0
data[1]为1
data[2]为2
data[3]为3
data[4]为4
data[5]为5
data[6]为6
data[7]为7
data[8]为8
data[9]为9
删除了第5个元素，为4
删除后的顺序表
data[0]为0
data[1]为1
data[2]为2
data[3]为3
data[4]为5
data[5]为6
data[6]为7
data[7]为8
data[8]为9

6  顺序表的按位查找

int GetElem(SqList &L,int i)
{
	return L.data[i-1];
}

注意数据类型一致，如果GetElem前的类型变为ElemType，结构体指针的类型也要一起变为ElemType。

举例：

#include<stdio.h>
#define MaxSize 10//定义最大长度
typedef struct
{
	int data[MaxSize];//用静态数组存放数据元素
	int length;//顺序表的当前长度
}SqList;//顺序表的类型定义
void InitList(SqList &L)//初始化一个顺序表
{
	for(int i=0;i<MaxSize;i++)
		L.data[i]=0;//将所有数据元素设置为0
	L.length=0;//顺序表初始长度为0
}
int GetElem(SqList &L,int i)
{
	return L.data[i-1];
}
int main()
{
	int e;
	SqList L;//声明一个顺序表
	InitList(L);//初始化顺序表
	printf("顺序表\n");
	for(int t=0;t<MaxSize;t++)
	{
		L.data[t]=t*t;
		printf("data[%d]为%d\n",t,L.data[t]);//打印顺序表每个元素
		L.length++;
	}
	e=GetElem(L,8);
	printf("L中第8个值为%d\n",e);
	return 0;
}

顺序表
data[0]为0
data[1]为1
data[2]为4
data[3]为9
data[4]为16
data[5]为25
data[6]为36
data[7]为49
data[8]为64
data[9]为81
L中第8个值为49

6  顺序表的按值查找

int LocateElem(SqList L,int e)
{
	for(int i=0;i<L.length;i++)
		if(L.data[i]==e)
			return i+1;
		return 0;
}

举例：

#include<stdio.h>
#define MaxSize 10//定义最大长度
typedef struct
{
	int data[MaxSize];//用静态数组存放数据元素
	int length;//顺序表的当前长度
}SqList;//顺序表的类型定义
void InitList(SqList &L)//初始化一个顺序表
{
	for(int i=0;i<MaxSize;i++)
		L.data[i]=0;//将所有数据元素设置为0
	L.length=0;//顺序表初始长度为0
}
int LocateElem(SqList L,int e)
{
	for(int i=0;i<L.length;i++)
		if(L.data[i]==e)
			return i+1;
		return 0;
}
int main()
{
	SqList L;//声明一个顺序表
	InitList(L);//初始化顺序表
	printf("顺序表\n");
	for(int t=0;t<MaxSize;t++)
	{
		L.data[t]=2*t;
		printf("data[%d]为%d\n",t,L.data[t]);//打印顺序表每个元素
		L.length++;
	}
	printf("L中值为10的元素在第%d个位置\n",LocateElem(L,10));
	return 0;
}

顺序表
data[0]为0
data[1]为2
data[2]为4
data[3]为6
data[4]为8
data[5]为10
data[6]为12
data[7]为14
data[8]为16
data[9]为18
L中值为10的元素在第6个位置

7 结构类型的比较

#include<stdio.h>
typedef struct
{
	int n;
	int a;
}p;
void pp()
{
	p i;
	i.n=1;
	i.a=2;
	p t;
	t.n=1;
	t.a=2;
	if(i.n==t.n&&i.a==t.a)
		printf("相等\n");
	else
		printf("不相等\n");
}
int main()
{
	pp();
	return 0;
}

相等

黏豆包儿~
关注
专栏目录
线性表（部分）
qq_45878468的博客
01-17 1963
从本节到接下来的几节讨论的线性表、栈、队列、串和数组都属于线性结构。线性结构的基本特点是除第一个元素无直接前驱，最后一个元素无直接后继之外，其他每个数据元素都有一个前驱和后继。 1.1 线性表的定义和特点 同一线性表中的元素必定具有相同的特性，即属于同一数据对象，相邻数据元素之间存在着序偶关系。 诸如此类由n（n>=0）个数据特性相同的元素构成的有限序列称为线性表。 线性表中元素的个...
【数据结构】线性表的顺序存储
DAY I 的成长之路
04-24 4398
💯线性表是具有相同类型的数据类型的n个数据元素的有限序列，其中n为表长，n0n=0n0时为空表ege.geg这里要注意的是，定义中描述的为数据元素，而非数据项，也就是，存储单元可以是一个结构体，而数据项为里面的成员✨线性表的特点：表中元素的个数为有限个表中元素具有逻辑上的顺序性，表中元素有其先后顺序表中元素都是数据元素，每一个元素都为单个元素表中元素的数据类型都相同，每个元素占相同的内存空间表中元素具有抽象性，即仅讨论元素之间的逻辑关系，而不考虑具体实现方式🔑。
Day61 数据结构（线性表、链表）
AppreciateIt的博客
11-07 616
数据结构（线性表、链表）
day01 1.数据结构相关内容2.线性表3.顺序表
m0_55984508的博客
07-19 902
1、顺序存储：使用一片连续的存储空间，存储上述逻辑结构的元素，特点：逻辑上相邻的元素，物理内存上也连续。2、链式存储：使用多个随机地址空间存储上述逻辑结构的元素，特点：逻辑上相邻的元素，物理内存上不一定相邻。3> 顺序表的表示方式：除了使用一个连续的内存存储顺序表外，还需要外加一个表示顺序表实际长度的变量完成。2> 特点：除了第一个元素没有前驱，最后一个元素没有后继外，其他的数据元素有且仅有一个前驱和一个后继。5> 数据之间的关系：数据项 ==> 数据元素 ==> 数据对象 ==> 数据。
线性表——顺序表与链表
rr_R_rr的博客
05-25 953
当1
【数据结构】线性表的链式存储
DAY I 的成长之路
05-08 3532
💯针对顺序存储的缺点，我们可以进行优化，也就得到了链式存储结构，它通过链建立起数据元素之间的逻辑关系，头指针：L，用来标识一个单链表，头指针为NULL时表示一个空表头结点：放在单链表的第一个元素之前，不存放信息，只是起到利于操作的作用（一般不计入表长），头结点的指针域指向线性表的第一个元素
Day3-数据结构-顺序表
ck0056的博客
07-18 118
【代码】Day3-数据结构-顺序表。
Leap Day5——数据结构与算法 线性表基础练习题
胖虎虎
01-11 1280
目录 1、顺序表 1.1 存储定义 1.2 构造顺序表 1.3 静态初始化顺序表 1.4 顺序表的元素输出 1.5 顺序表的 插入 1.6 顺序表的删除 1.7 顺序表的取值 1.8 顺序表的查找 2、单链表 2.1 单链表的存储定义 2.2 头插法创建单链表 2.3 单链表的插入 2.4 单链表的删除 2.5 单链表的取值 2.6 单链表的查找 1、顺序表 1.1 存储定义 顺序表的存储定义 typedef st...
嵌入式学习day15(顺序表)
m0_37565374的博客
03-15 93
顺序表
数据结构(逻辑结构、存储结构、顺序表，链表)学习笔记-day8
weixin_47409584的博客
04-28 1119
这里对今天所学数据结构进行总结：主要学习数据结构，了解数据的逻辑结构、存储结构；线性表中的顺序表、链式表（单向链表、单向循环列表、双向表）；栈（顺序栈）和顺序队队列以及相应的本质，代码量较大，加油！！
数据结构课程设计 - 通讯录管理系统
热门推荐
hades's stack
07-06 3万+
设计并实现一个简单通讯录管理系统。 实现通讯录的建立、通讯者的删除、查询，以及通讯录的保存。 本系统为简单的通讯录管理系统，运行系统时，将从文件中读取已有的数据内容记录在内存中，使用者可以对通讯录进行添加、删除、修改、浏览、查找等操作，每进行一项操作后将内存中的数据写入到文件中，同时并记录操作者的操作内容和当地时间并记录到当前文件夹下的Log.dat文件中。
数据结构-day2-栈（先进后出）和队列（先进先出）-C/C++
weixin_45728192的博客
04-18 3960
文章目录1.0栈的定义1.1栈的基本操作1.2栈的基本操作的实现1.3栈的应用举例1.4C++中的栈 1.0栈的定义 1.1栈的基本操作 1.2栈的基本操作的实现 1.3栈的应用举例 1.4C++中的栈
常用API及数据结构
black210的博客
03-18 1312
1.常用API 1.1. String 类 概述 java.lang.String 类代表字符串。 类 String 中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串以及创建具有翻译为大写或小写的所有字符的字符串的副本。 常量对象：字符串常量对象是用双引号括起的字符序列。 例如（"abc" ） 特点 字符串不变：String是一个final类，字符串的值...
数据结构与算法
weixin_41560737的博客
08-25 298
数据结构与算法-Day01 算法概述 算法-前序 【1】Everybody!全场动作必须跟我整齐划一，来，我们一起来做一道题 若n1+n2+n3=1000,且n1^2+n2^2=n3^2(n1,n2,n3为自然数),求出所有n1、n2、n3可能的组合 【2】解题思路 n1 = 0 n2 = 0 n3 = 0 判断n1+n2+n3是否等于1000,之后变n3=1,n3=2,n3=3,... 然后再变n2 【3】代码实现 import time
数据结构——笛卡尔树详解
数据结构和算法
10-22 657
前面我们讲过《堆》和《二叉搜索树》，能不能把这两种数据结构的特性结合起来构造一棵新的树呢？当然是可以的，这个就是我们这里要讲的笛卡尔树(笛卡尔树的每个节点有两个值(x，y)，其中一个满足二叉搜索树的特性，一个满足堆的特性，所以笛卡尔树是一棵具有二叉搜索树和堆的两种特性的二叉树笛卡尔树中节点的两个值分别是数组中元素的值，和该元素在数组中的下标，其中元素的值满足堆的特性，元素的下标满足二叉搜索树的特性。下面使用数组构造一棵笛卡尔树。
二叉树的性质
2401_83624776的博客
10-18 1170
二叉树的基本概念与性质（适合复习用）
Python实现非线性数据结构-字典、集合、树、图
captain
10-22 256
存储键值对，内部使用哈希表实现。时间复杂度是 O(1)， 创建、新增、查询、删除键值对，访问值、修改值。：无序的、不包含重复元素的数据结构。支持并集、交集、差集。内部使用哈希表实现。添加、删除、检查元素是否存在。非线性数据结构：数据不遵循线性顺序，根据特定的关系或规则来组织数据。：由节点和连接这些节点的边组成。分为有向图(边有方向)和无向图。每个节点有一个值并且可以有0个或多个子节点。
数据结构预备知识---Java集合框架、List接口、包装类、装箱拆箱和泛型
最新发布
2401_83147199的博客
10-25 806
Java集合框架，List接口的介绍，装箱拆箱、包装类和泛型
数据结构：树和二叉树
qingttqing的博客
10-25 754
二叉树的基本概念；二叉树的查找采用递归函数即可进行；二叉树与树和森林转换；二叉树的应用；二叉查找树
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值