【数据结构复习—线性表1.0】

已于 2022-05-06 17:02:27 修改
阅读量780 收藏
点赞数 1
文章标签： 数据结构 c++ c语言 算法
于 2022-05-04 00:03:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51111589/article/details/124555319
版权

系列文章目录

第一章：线性表的定义和基本操作
第二章：双链表

线性表的定义和基本操作

一、线性表的顺序表示

线性表的顺序存储又称顺序表。它是用一组地址连续的存储单元一次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。第1个元素存储在线性表的起始位置，第i个位置存储位置紧接着存储的是第i+1个元素，称I为元素ai在线性表中的位序。

1.数组描述顺序存储结构

首先是定义结构体，对数组进行静态分配，当然也可以进行动态分配。
静态分配的话，数组的大小和空间是已经固定了的，一旦空间占满，再加入新的数据就会溢出使得程序崩溃。而动态分配的话就不这样，动态分配中存储数组的空间是在程序执行过程中通过动态存储分配语句来分配的，一旦空间占满的话，就会开辟新的更大的空间来替换掉以前的空间。

C语言的初始动态分配的语句：
L.data=(ElemType* )malloc(sizeof(ElemType)* InitSize);
C++的初始动态分配的语句：
L.data=new ElemType(InitSize);

注意：线性表中的元素的位序是从1开始，而数组中的元素下标是从0开始。

代码如下（静态分配）：

#define MaxSize 50  //定义线性表的最大长度
typedef int ElemType;

//静态分配
typedef struct {
	ElemType data[MaxSize];  //顺序表的元素
	int length;  //顺序表的长度
}SqList; //顺序表的类型

2.顺序表的基本操作

（1）插入操作
在顺序表L中第i（1<i<length+1）个位置插入一个新元素e，如果i的的输入不合法，则显示插入失败返回FALSE，反之，则腾出一个新的位置插入新元素e，并将第i个元素及其后面的元素向后移一个位置，顺序表的长度+1。

代码如下：

//插入元素
bool ListInsert(SqList& L, int i, ElemType e)
{
	if (i<1 || i>L.length + 1)  //判断i的范围是否有效
		return false;
	if (L.length >= MaxSize)  //大于存储空间的话则插入失败
		return false;
	for (int j = L.length; j >= i; j--)  // 将第i个元素及之后的元素向后移
		L.data[j] = L.data[j - 1];
	L.data[i - 1] = e;  //在位置i处放入e
	L.length++;  //线性表长度加1
	return true;
}

若在表头插入元素，则i=1，后面元素将执行n次后移，时间复杂度为O(n)。
若在表尾插入元素，则i=n+1，整体元素不需要移动，时间复杂度为O(1)。
若在表中插入元素，则需要将第i个元素及其后面的元素向后移一个位置，平均时间负责度是O(n)。

（2）删除操作
删除顺序表L中的第i（1<i<length+1）个元素，使用引用变量e返回，若i的输入不合法，则删除失败返回FALSE，反之，将要删除的元素赋值给e，并且将删除的第i个元素及其后面的元素向前移动一个位置，顺序表的长度-1。

代码如下：

//删除元素
bool ListDelete(SqList& L, int i, ElemType& e) {  //使用c++的引用（使用&）是因为要改变里面的值，即删除，比如查询跟插入就不需要
	if (i<1 || i>L.length + 1)
		return false;
	if (L.length == 0)
		return false;
	e = L.data[i - 1];  //将被删除的元素赋值给e
	for (int j = i; j < L.length; j++)  //将第i个元素后面的元素向前移
		L.data[j - 1] = L.data[j];
	L.length--;  //线性表长度减1
	return true;
}

若删除表头，则i=1，需要移动除表头外的所以元素，时间复杂的为O(n)。
若删除表尾，则i=n，不需要移动，时间复杂度为O(1)。
若删除其中一个元素，则需要将删除的第i个元素及其后面的元素向前移动一个位置，平均时间复杂度为O(n)。

（3）查找操作
查找顺序表中的第i个元素，引用变量e，循环数组，查询与e匹配的值并返回。

代码如下：

//查找元素
int LocateElem(SqList L, ElemType e)
{
	int i;
	for (i = 0; i < L.length; i++)
		if (L.data[i] == e)
			return i + 1;  //+1代表元素在顺序表中的位置
	return 0;
}

若查找的元素在表头，则只需要比较一次，时间复杂度为O(1)。
若查找的元素在表尾（或者不存在）时，则需要比较n次，时间复杂度为O(n)。
若查找的元素在中间，平均时间复杂度为O(n)。

二、线性表的链式表示

1.单链表的定义

线性表的单链表又称单链表，它是通过一组任意的存储单元来存储线性表中的数据元素。为了建议数据元素之间的线性关系，对每个链表结点，除了存放自身信息外，还需要存放一个指向其后继的指针。
单链表结点结构
通常，为了操作的方便，会在单链表第一个结点之前附加一个结点，称为头结点。头结点的数据域可以是空。头结点的指针域指向线性表的第一个元素的结点。

单链表中结点类型的描述：
代码如下：

typedef int ElemType;
typedef struct LNode {  //定义单链表结点类型
	ElemType data;  //数据域
	struct LNode* next;  //指针域
}LNode,*LinkList;

2.单链表的基本操作

（1）头插法建立单链表
该方法从一个空表开始，生成新结点，并将读取到的数据存放在新结点的数据域中，然后将新结点插入到当前链表的表头，即头结点之后。但是插入的顺序在显示的时候是逆序显示。
头插法

代码如下：

//头插法
LinkList CreatList1(LinkList& L) {
	LNode* s; int x;
	L = (LinkList)malloc(sizeof(LNode));  //创建头结点
	L->next = NULL;  //初始为空链表
	scanf_s("%d", &x);  //输入结点的值
	while (x != 999)  //再输入999之后表示结束
	{
		s = (LinkList)malloc(sizeof(LNode));  //创建新的结点s，给其申请空间，并强制类型转换
		s->data = x;  //将读取到的值给新空间s中的data成员
		s->next = L->next;  //让新结点的next指针指向链表的第一个元素
		L->next = s;  //让s作为第一个元素，值为x
		scanf_s("%d", &x);
	}
	return L;
}

（2）尾插法建立单链表
尾插法跟头插法的区别就是显示插入数据的次序不一样，尾插法是按插入顺序显示。
增加一个尾指针r，使其始终指向当前链表的尾结点。
尾插法

代码如下：

//尾插入法
LinkList CreatList2(LinkList& L) {
	int x;
	L = (LinkList)malloc(sizeof(LNode));
	LNode* s, * r = L;  //r为表尾的指针
	scanf_s("%d", &x);
	while (x!=999)
	{
		s = (LinkList)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;  //让尾部结点指向新的结点
		r = s;  //r指向新的表尾结点
		scanf_s("%d", &x);
	}
	r->next = NULL;  //尾结点指针置空
	return L;
}

（3）按序号查找结点值
在单链表中从第一个结点出发，顺时针next域逐个往下搜索，直到找到第i个结点为止，否则返回最后一个结点指针域null。

代码如下：

//按序号查找结点值
LinkList GetElem(LinkList L, int i)
{
	int j = 1;  //计数，初始为1 
	LinkList p = L->next;  //第1个结点指针赋给p
	if (i == 0)
		return L;
	if (i < 1)
		return NULL;
	while (p && j < i)  //从第1个结点开始找，查找第i个结点
	{
		p = p->next;
		j++;
	}
	return p;
}

（4）按值查找表结点
引用变量e，并将目标值赋值给e，在单链表中从第一个结点开始比较各结点数据域的值，找到匹配值则返回结点指针，否则返回最后一个结点的指针域 NULL。

代码如下：

//按值查找表结点
LinkList LocateElem(LinkList L, ElemType e)
{
	LinkList p = L->next;
	while (p != NULL && p->data!=e)  //从第1个结点开始查找data域为e的结点
	{
		p=p->next;
		return p;
	}
}

（5）插入结点
插入结点操作即将值为x的新结点插入到单链表中的第i个位置，显示检查插入的位置是否合法，然后找到插入元素的前驱结点，即第i-1个结点，再在其后插入新结点。
算法首先调用按序号查找算法GetElem(L,i-1)，查找第i-1个结点。假设返回的第i-1个结点为* p，然后令新结点* s的指针域指向* p的后继结点，再令结点* p的指针域指向新插入的新结点* s。
插入
图中的第1步跟第2步顺序不能颠倒，否则，指执行p->next = s后，指向其原后继的指针就不存在了，再执行s->next = p->next，相当于执行了s->next =s，显然是不行的。

代码如下：

//在第i个位置插入元素
bool ListFrontInster(LinkList L, int i, ElemType e)
{
	LinkList p = GetElem(L, i - 1);  //查找插入元素的前驱结点
	if (p == NULL)
	{
		return false;
	}
	LinkList s = (LinkList)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

（6）删除结点
将单链表中的第i个结点删除，先检查删除的位置是否合法，后查找表中第i-1个结点，即被删除结点的前驱结点，再将其删除。
假设结点* p为找到的被删除结点的前驱结点，再将* p的指针域next指向*q的下一结点。

代码如下：

//删除元素
bool ListDelete(LinkList L, int i)
{
	LinkList p = GetElem(L, i - 1);
	if (p == NULL)
	{
		return false;
	}
	LinkList q = p->next;  //令q指向被删除结点
	p->next = q->next;  //将*q结点从链中“断开”
	free(q);  //释放结点的存储空间
	q = NULL;  //避免野指针
	return true;
}

三、顺序表和链式表的增删查代码汇总

1.顺序表

注：以上分布讲解的代码均为伪代码，下面的代码是总的汇总，可直接复制并运行。

代码如下：

#include<stdio.h>

#define MaxSize 50  //定义线性表的最大长度
typedef int ElemType;

//静态分配
typedef struct {
	ElemType data[MaxSize];  //顺序表的元素
	int length;  //顺序表的长度
}SqList; //顺序表的类型

//打印线性表
void PrintList(SqList& L)
{
	for (int i = 0; i < L.length; i++)
	{
		printf("%4d", L.data[i]);
	}
	printf("\n");
}

//插入元素
bool ListInsert(SqList& L, int i, ElemType e)
{
	if (i<1 || i>L.length + 1)  //判断i的范围是否有效
		return false;
	if (L.length >= MaxSize)  //大于存储空间的话则插入失败
		return false;
	for (int j = L.length; j >= i; j--)  // 将第i个元素及之后的元素向后移
		L.data[j] = L.data[j - 1];
	L.data[i - 1] = e;  //在位置i处放入e
	L.length++;  //线性表长度加1
	return true;
}

//删除元素
bool ListDelete(SqList& L, int i, ElemType& e) {  //使用c++的引用（使用&）是因为要改变里面的值，即删除，比如查询跟插入就不需要
	if (i<1 || i>L.length + 1)
		return false;
	if (L.length == 0)
		return false;
	e = L.data[i - 1];  //将被删除的元素赋值给e
	for (int j = i; j < L.length; j++)  //将第i个元素后面的元素向前移
		L.data[j - 1] = L.data[j];
	L.length--;  //线性表长度减1
	return true;
}

//查找元素
int LocateElem(SqList L, ElemType e)
{
	int i;
	for (i = 0; i < L.length; i++)
		if (L.data[i] == e)
			return i + 1;  //+1代表元素在顺序表中的位置
	return 0;
}

int main()
{
	SqList L;
	bool ret;  //查看返回值，bool型是true，或者是false
	L.data[0] = 1;
	L.data[1] = 2;
	L.data[2] = 3;
	L.length = 3;
	ret = ListInsert(L, 2, 60);  //在L表中的第2个位置插入60
	if (ret)
	{
		printf("插入成功\n");
		PrintList(L);
	}
	else {
		printf("插入失败\n");
	}
	ElemType del;  //删除
	del = ListDelete(L, 1, del);
	if (del)
	{
		printf("删除成功\n");
		PrintList(L);
		printf("删除成功的值是：%d\n", del);
	}
	else {
		printf("删除失败\n");
	}
	int loc;  //查找
	loc = LocateElem(L, 60);
	if (loc)
	{
		printf("查找成功\n");
		printf("元素位置为%d\n",ret);
	}
	else
	{
		printf("查找失败\n");
	}
	return 0;
}

2.单链表

代码如下：

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

typedef int ElemType;
typedef struct LNode {  //定义单链表结点类型
	ElemType data;  //数据域
	struct LNode* next;  //指针域
}LNode,*LinkList;

//链表打印
void PrintList(LinkList L) {
	L = L->next;
	while (L!=NULL)
	{
		printf("%4d", L->data);
		L = L->next;
	}
	printf("\n");
}

//头插法
LinkList CreatList1(LinkList& L) {
	LNode* s; int x;
	L = (LinkList)malloc(sizeof(LNode));  //创建头结点
	L->next = NULL;  //初始为空链表
	scanf_s("%d", &x);  //输入结点的值
	while (x != 999)  //再输入999之后表示结束
	{
		s = (LinkList)malloc(sizeof(LNode));  //创建新的结点s，给其申请空间，并强制类型转换
		s->data = x;  //将读取到的值给新空间s中的data成员
		s->next = L->next;  //让新结点的next指针指向链表的第一个元素
		L->next = s;  //让s作为第一个元素，值为x
		scanf_s("%d", &x);
	}
	return L;
}

//尾插入法
LinkList CreatList2(LinkList& L) {
	int x;
	L = (LinkList)malloc(sizeof(LNode));
	LNode* s, * r = L;  //r为表尾的指针
	scanf_s("%d", &x);
	while (x!=999)
	{
		s = (LinkList)malloc(sizeof(LNode));
		s->data = x;
		r->next = s;  //让尾部结点指向新的结点
		r = s;  //r指向新的表尾结点
		scanf_s("%d", &x);
	}
	r->next = NULL;  //尾结点指针置空
	return L;
}

//按序号查找结点值
LinkList GetElem(LinkList L, int i)
{
	int j = 1;  //计数，初始为1 
	LinkList p = L->next;  //第1个结点指针赋给p
	if (i == 0)
		return L;
	if (i < 1)
		return NULL;
	while (p && j < i)  //从第1个结点开始找，查找第i个结点
	{
		p = p->next;
		j++;
	}
	return p;
}

//按值查找表结点
LinkList LocateElem(LinkList L, ElemType e)
{
	LinkList p = L->next;
	while (p != NULL && p->data!=e)  //从第1个结点开始查找data域为e的结点
	{
		p=p->next;
		return p;
	}
}

//在第i个位置插入元素
bool ListFrontInster(LinkList L, int i, ElemType e)
{
	LinkList p = GetElem(L, i - 1);  //查找插入元素的前驱结点
	if (p == NULL)
	{
		return false;
	}
	LinkList s = (LinkList)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

//删除元素
bool ListDelete(LinkList L, int i)
{
	LinkList p = GetElem(L, i - 1);
	if (p == NULL)
	{
		return false;
	}
	LinkList q = p->next;  //令q指向被删除结点
	p->next = q->next;  //将*q结点从链中“断开”
	free(q);  //释放结点的存储空间
	q = NULL;  //避免野指针
	return true;
}

int main()
{
	LinkList L;
	LinkList search;
	CreatList1(L);
	PrintList(L);
	CreatList2(L);
	PrintList(L);
	search = GetElem(L, 2);
	if (L != NULL)
	{
		printf("按序号查找成功\n");
			printf("%4d\n", search->data);
	}
	search = LocateElem(L, 3);
	if (search != NULL)
	{
		printf("按值查找成功\n");
			printf("%4d\n", search->data);
	}
	ListFrontInster(L, 2, 99);
	PrintList(L);
	ListDelete(L, 4);
	PrintList(L);
	return 0;
}

总结

这是复习数据结构中第二章线性表的前两个知识点的总结，顺序表的话相对来说比较简单且使用的并不是很多，单链表的话就比较常见，后面还有双链表之类的，如果有什么不错误的地方还希望大家能够指点指点。希望自己的总结能够对大家有所帮助，如果对你能有所帮助就点赞收藏支持我呗！

Mars2.0
关注
oj做题c语言
Hello大家好，我是Dream，如果帮得到你，那我深感荣幸！交流学习、商务合作：https://bbs.csdn.net/topics/614347534
08-18 1万+
输入两个整数A,B，用空格隔开输出一个整数，表示这两个数的和数据范围0≤A,B≤108。
【数据结构】线性表
qq_45972928的博客
04-27 782
线性表知识结构1、线性表定义和基本操作1.1 线性表定义1.2 基本操作2、线性表的实现2.1 顺序实现（顺序存储）2.1.1 顺序表定义2.1.2 基本操作实现2.2 链式实现2.2.1 单链表（指针实现）2.2.2 双链表（指针）2.2.3 循环链表（指针）2.2.4 静态链表（数组）3、编程实现（部分） 1、线性表定义和基本操作 1.1 线性表定义 定义：是具有相同数据元素的n(n>=0)个数据元素的有限序列，记为L。线性有序的逻辑结构 其中n为表长，当n=0时是一个空表 a1为表头元素，只
数据结构（一）线性表
StormMaybin的博客
07-15 1418
/** *@author StormMaybin *@Date 2016-07-15 */ 每一个成功者都有一个开始。勇于开始,才能找到成功的路。 是时候总结一下数据结构的知识了，总共会分为五篇文章来进行总结一、 概念线性表（Linear_list）是最常用也是最简单的数据结构。简言之，一个线性表是n个数据元素的有限序列。线性表是有线性结构的表。什么是线性结构呢？线性结构是n个数据元素的有序集合
数据结构1：线性表
qq_61635925的博客
04-25 414
1.关于线性表 线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。 线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储，但是把最后一个数据元素的尾指针指向了首位结点）。 线性表的逻辑结构简单，便...
2021-12-18 数据结构——线性表(上) (c++代码和c代码)
名幕新星的博客
12-17 1311
线性表是最基本、最简单、也是最常用的一种数据结构。==线性表（linear list）==是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。 1.基本概念 线性表：零个或多个数据元素的有限序列。 线性表：包括顺序表和链表 顺序表（数组）：里面元素的地址是连续的， 链表：链表里面节点的地址不是连续的，是通过指针连起来的。 表中元素个数称为线性表的长度 线性表没有元素时，称为空表 表起始位置称为表头，表结束位置称表尾 2. 线性表的抽象数据类型 类型名称：线性表（List） 操作集：线性表 L
【数据结构篇】线性表1 --- 顺序表、链表 （万字详解！！）
iiiiiihuang的博客
09-03 2593
前言：这篇博客我们重点讲线性表中的顺序表、链表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
数据结构c语言大题答案,数据结构c语言版试题大全（含答案）
weixin_42701905的博客
05-18 2241
if (i*1.0>sqrt(n))printf \是一素数\ elseprintf \不是一素数\}(2) sum1(int n)- 9 -{int p=1,sum=0,i; for (i=1;i<=n;i++) {p*=i; sum+=p; }returm (sum); }(3) sum2(int n)...
C#数据结构详细信息
04-17
- **数据结构详解**：第2章至第6章详细探讨了线性表、栈和队列、字符串和数组、树型结构和图结构等常见数据结构。每种结构都有详细的介绍，包括其定义、性质、应用场景以及具体的实现方法。此外，每一章还介绍了.NET...
java基础复习（六）：容器类库
qq_44793993的博客
06-02 884
文章目录理解容器的本质容器与数组容器的最佳实践思考：set、list、map接口ArrayList和linkedList共同点思考细节对比选择双向链表还是单链表选择链表还是数组随机访问复杂度对比hashMaphashCode（）与hash（）哈希函数的作用hashCode的作用分析hashCode的实现（31）扩容原理jdk7死循环的产生对比1.7与1.8的hashMap实现阈值问题什么是loadfactor为啥树化阈值为8，而恢复为6红黑树性质解决哈希冲突的办法哈希函数的其他实现put与get方法的实现简
信息检索专题复习
热门推荐
到处转一圈，总有你需要的
06-20 1万+
信息检索复习重点，山东大学信息检索考前独家整理资料。
#define MaxSize 50
最新发布
2301_79629384的博客
02-28 593
的常量，其值为 50。这个常量通常用于表示线性表（或数组）在程序中的最大容量或大小。意味着线性表（作为数组实现）已经分配了最多能容纳。语句，而不是在代码中查找特定的数值，可以轻松地更改最大大小。这样的定义有助于维护数组或数据结构的大小，并且通过修改。这个语句中，它定义了一个名为。
C数据结构-线性表
two_apples的博客
03-10 259
#include &lt;stdio.h&gt; #define Maxsize 50 #define Elemtype int typedef struct{ Elemtype data[Maxsize];//数据类型 int length; //数据长度 }Sqlist; //顺序表的类型定义 //int i,j; //插入操作 bool Listinser...
数据结构 - 第2章 线性表（一）顺序表
qq_44197482的博客
09-23 153
线性表一：顺序表 线性表不管在考试还是学习的过程中都是数据结构的重点之一，也算不上难点，好好理解还是不会有太大问题的，因此需要在熟悉基本定义的情况下好好琢磨琢磨。 1.本章重难点 线性表的定义和基本操作 线性表的实现（物理结构：顺序存储、链式存储；线性表的应用） 2.线性表的定义和基本操作 有限个相同数据类型组成的序列叫做线性表（10个int型数据拼在一起这样子～） 线性表的基本操作涉及到很多代码，在后面遇到的时候敲一下 3.线性表的顺序表示 线性表的顺序存储就成为顺序表 不管是C的数组、Java
数据结构—查找(Part Ⅰ)—顺序/折半/分块查找
Miss Z的博客
09-16 1536
数据结构-查找(第九章)的整理笔记，若有错误，欢迎指正。
【考研】数据结构考点——直接插入排序
qq_34438969的博客
08-03 3526
本文内容源于对《数据结构（C语言版）》（第2版）、王道讲解学习所得心得、笔记整理和总结。插入排序的三种方法：直接插入排序、折半插入排序和希尔排序。本文内容主要针对直接插入排序，包括了基于顺序表、带头结点单链表和不带头结点单链表的直接插入排序算法。CSDN21天学习挑战赛。......
【数据结构】排序
WINGREZ‘S BLOG
10-17 286
参考资料：《数据结构（C语言版）严蔚敏著》 版权说明：未经作者允许，禁止转载。如引用本文内容，需标明作者及出处。如本文侵犯了您的权益，请联系我删除并致歉。 文章说明：如文章中出现错误，请联系我更改。如您对文章的内容有任何疑问，也欢迎来与我讨论。 本文正在施工中...请稍等... 排序 基本概念 1、排序：将一个数据元素的任意序列，重新排列成一个按关键字有序的序列。假设待排序的序列中有两个数据...
二十四点问题
qq_45670253的博客
08-16 899
【题目背景】 二十四点是一款著名的纸牌游戏，其游戏的目标是使用3个加减乘除运算使得4张纸牌上数字的运算结果为24. 【题目描述】 定义每一个游戏由4个从1-9的数字和3个四则运算符组成，保证四则运算符将数字两两隔开，不存在括号和其他字符，运算顺序按照四则运算顺序进行。加法用+表示，减法用-表示，乘法用小写字母x表示，除法用/表示。在游戏里除法为整除。 老师给了你n个游戏的解，请你编写程序验证每个游戏的结果是否为24. 【输入格式】 从标准输入读入数据。 第一行输入一个整数n，从第二行开始到第n+1行中，每一
设循环队列的容量为50（1—50）经过入队退队运算有front=26rear=15。问队列中有多少元素？...
weixin_33862993的博客
06-12 2390
（1）Front指向循环队列起始位置的第一个，因此后面的所有元素有50-Front+1 = 50-26+1 = 25个Rear指向循环队列最后一个元素的下一个，因此前面的所有元素是15-1 = 14个，由于Rear小于Front，则Front后面的和Rear前面的全部都在队列中，因此一共有25+14 = 39个元素。（2）由上面可知，公式是如果Rear小于Front，元素个数是50-Front+1...
C&C++关于数组的定义，引用传参问题
猿始森林
02-07 2325
C&C++关于数组的定义，引用传参问题 （1）数组的定义         #define maxSize 50         static int length = 10;         正确定义方法：int array[maxSize];          错误定义方法：int array[length];             分析：数组的 [ ]中只能放
Java数据结构复习：线性表实现与应用
"Java基础复习笔记04数据结构-线性表" 这篇复习笔记主要涵盖了Java中的数据结构——线性表。线性表是一种基本的数据结构，它包含了一组有序的元素，每个元素都有一个唯一的索引。在Java中，线性表可以由数组或链表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值