正文 

当前位置： 首页 > 技术 > java教程

02线性表之顺序表(代码片段)

再吃一个橘子 再吃一个橘子     2022-12-24     667

关键词：

肚子饿了就要吃   ~   嗝  ——— 路飞 

目录

1.本章重点

2.线性表

3.顺序表实现

3.1顺序表的概念及结构

4.静态顺序表

5.动态顺序表 

5.1“增”

尾插：

头插：

5.2“删”

尾删

头删

5.3随机“插入”

5.4随机“删除”

5.5内存销毁

5.6“改”

5.7“查”

6.顺序表相关OJ练习题

6.1原地移除元素

6.2合并两个有序数组

1.本章重点

1.线性表概念
2.顺序表实现
3.顺序表相关OJ题练习


2.线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

3.顺序表实现

3.1顺序表的概念及结构

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。
顺序表一般可以分为：
1. 静态顺序表：使用定长数组存储。
2. 动态顺序表：使用动态开辟的数组存储。 

4.静态顺序表

但是这样写代码的可维护性并不高，比如我们想要修改数组的内存空间变得更长，那是不是需要每个地方的a[ N ]都要修改？再比如，我们想要把数组的数据类型变一下，那也是不是都需要改？所以，可见代码可读性并不高，我们需要自定义一下：

#pragma once

#define MAX_SIZE 100
typedef int SQDataType;

//可维护性增强
struct SeqList

	SQDataType a[MAX_SIZE];//自定义了数据类型，数组大小
	int size;
;

但是，仅仅这样，用struct Stu结构体类型来定义变量，过于冗余，一般会用重命名的方式再来把struct Stu这个结构体类型重新命名一下，比如：

#pragma once

#define MAX_SIZE 100
typedef int SQDataType;

//可维护性增强
typedef struct SeqList

	SQDataType a[MAX_SIZE];//自定义了数据类型，数组大小
	int size;
SL;

//用typedef将struct SeqList结构体类型定义成SL，方便后续用结构体类型定义变量，避免冗余

当然也可以这样分开写：

#pragma once

#define MAX_SIZE 100
typedef int SQDataType;

//可维护性增强
struct SeqList

	SQDataType a[MAX_SIZE];//自定义了数据类型，数组大小
	int size;
;

typedef struct SeqList;//分开写

顺序表主要是完成对数据的增删改查：

我们想要对数组进行初始化，该怎么做？

SeqList.h文件

#pragma once

#include<stdio.h>
#define MAX_SIZE 100
typedef int SQDataType;

//可维护性增强
typedef struct SeqList

	SQDataType a[MAX_SIZE];//自定义了数据类型，数组大小
	int size;
SL;

//增删改查接口函数

//初始化
void SeqListInit(SL s);

SeqList.c文件

#include"SeqList.h"

//初始化数组为0
//要用到的数组空间也初始化为0
void SeqListInit(SL s)

	memset(s.a, 0, sizeof(SQDataType) * MAX_SIZE);//初始化数组为0
	s.size = 0;//要用到的数组空间也初始化为0

test.c文件

#define _CRT_SECURE_NO_WARNINGS
#include"SeqList.h"

//测试
void TestSeqList1()

	SL sl;
	SeqListInit(sl);


int main()

	TestSeqList1();
	return 0;

我们调试发现，实参确实被初始化为0，但形参还是乱值，那如何也将形参也初始化呢？？   ————>    传地址

 SeqList.h文件

#pragma once

#include<stdio.h>
#define MAX_SIZE 100
typedef int SQDataType;

//可维护性增强
typedef struct SeqList

	SQDataType a[MAX_SIZE];//自定义了数据类型，数组大小
	int size;
SL;

//增删改查接口函数

//初始化
void SeqListInit(SL* ps);

SeqList.c文件

#include"SeqList.h"

//初始化数组为0
//要用到的数组空间也初始化为0
void SeqListInit(SL* ps)

	memset(ps->a, 0, sizeof(SQDataType) * MAX_SIZE);//初始化数组为0
	ps->size = 0;//要用到的数组空间也初始化为0

test.c文件

#define _CRT_SECURE_NO_WARNINGS
#include"SeqList.h"

//测试
void TestSeqList1()

	SL sl;
	SeqListInit(&sl);


int main()

	TestSeqList1();
	return 0;

 增删操作：

 SeqList.h文件

注意：

自定义声明例如：

头插void SeqListPushFront，可以自己随便定义名字，你也可以定义void SeqListInertFront或者其他写法

再如 头删：void SeqListPopFront，也可以定义void SeqListMoveFront或者void SeqListDeleteFront或者其他写法

只不过我现在的写法是C/C++库里的内容，方便后续学习。

//增删改查接口函数

//增
 
//头插
void SeqListPushFront(SL* ps, SQDataType x);
//尾插
void SeqListPushBack(SL* ps, SQDataType x);


//删
//头删
void SeqListPopFront(SL* ps);
//尾删
void SeqListPopBack(SL* ps);

SeqList.c文件

//增删改查

//增
 
//头插
void SeqListPushFront(SL* ps, SQDataType x)

	if (ps->size >= MAX_SIZE)
	
		printf("SeqList is Full!\\n");
		return;
	
	ps->a[ps->size] = x;
	ps->size++;


//尾插
void SeqListPushBack(SL* ps, SQDataType x)




//删
 
//头删
void SeqListPopFront(SL* ps)




//尾删
void SeqListPopBack(SL* ps)

但是我们发现，静态表，无论怎么做，都是会有缺点的，就比如说：

我们#define MAX_SIZE 100，那我们要是需要添加101个数据怎么办？你可能会说：“继续define呐！！”，但是这是个长久之计吗？？

又譬如：#define MAX_SIZE 1000，但是我们size = 100（需要用到的数组空间只有100），那是不是又浪费了？？

静态顺序表缺点总结：

少了不够用，多了浪费空间。

那么我们就引出了动态顺序表：

5.动态顺序表 

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态地分配空间大小，所以下面我们实现动态顺序表。

5.1“增”

尾插：

SeqList.h文件

#pragma once

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
//#define MAX_SIZE 10
typedef int SQDataType;

//可维护性增强
typedef struct SeqList

	SQDataType* a; //指向动态开辟的数组
	int size;      //有效数据的个数
	int capacity;  //容量空间大小
SL;

//初始化
void SeqListInit(SL* ps);


//增删改查接口函数

//增

//尾插
void SeqListPushBack(SL* ps, SQDataType x);

SeqList.c文件

#include"SeqList.h"

//初始化数组为0
//要用到的数组空间也初始化为0
void SeqListInit(SL* ps)

	ps->a = NULL;
	ps->size = 0;
	ps->capacity = NULL;


//增删改查

//增

//尾插
void SeqListPushBack(SL* ps, SQDataType x)

	//满了就要扩容
	if (ps->size == ps->capacity)//当size(有效数据个数)  ==  capacity(容量空间大小),数组空间刚好被用完
	
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;//这个4是随便初始的一个值，1也可以，2也可以，不够就往后尾插
		SQDataType* tmp = (SQDataType*)realloc(ps->a, newcapacity * sizeof(SQDataType));

		if (tmp == NULL)//如果扩容失败
		
			printf("realloc fail!");
			exit(-1);//结束
		
		else
		
			ps->a = tmp;//将新扩容的空间地址给指针变量a
			ps->capacity = newcapacity;
		
	

	ps->a[ps->size] = x;
	ps->size++;


//打印
void SeqListPrint(SL* ps)

	int i = 0;
	for (i = 0; i < ps->size; i++)
	
		printf("%d ", ps->a[i]);
	
	printf("\\n");

test.c文件

#define _CRT_SECURE_NO_WARNINGS
#include"SeqList.h"

//测试
void TestSeqList1()

	SL sl;
	SeqListInit(&sl);
	//尾插
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	SeqListPushBack(&sl, 6);
	SeqListPushBack(&sl, 7);
	SeqListPushBack(&sl, 8);
	SeqListPushBack(&sl, 9);
	SeqListPushBack(&sl, 10);
	SeqListPushBack(&sl, 11);

	//打印
	SeqListPrint(&sl);


int main()

	TestSeqList1();
	return 0;

解释：

扩容数组空间，当不够用的时候，2倍扩容空间（  一般规定就是二倍  ）

头插：

SeqList.h文件

#pragma once

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
//#define MAX_SIZE 10
typedef int SQDataType;

//可维护性增强
typedef struct SeqList

	SQDataType* a; //指向动态开辟的数组
	int size;      //有效数据的个数
	int capacity;  //容量空间大小
SL;

//初始化
void SeqListInit(SL* ps);


//增删改查接口函数

//增

//头插
void SeqListPushFront(SL* ps, SQDataType x);

 SeqList.c文件

#include"SeqList.h"

//初始化数组为0
//要用到的数组空间也初始化为0
void SeqListInit(SL* ps)

	ps->a = NULL;
	ps->size = 0;
	ps->capacity = NULL;


//增删改查

//增

//头插
void SeqListPushFront(SL* ps, SQDataType x)

	//满了就要扩容
	if (ps->size == ps->capacity)//当size(有效数据个数)  ==  capacity(容量空间大小),数组空间刚好被用完
	
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;//这个4是随便初始的一个值，1也可以，2也可以，不够就往后尾插
		SQDataType* tmp = (SQDataType*)realloc(ps->a, newcapacity * sizeof(SQDataType));

		if (tmp == NULL)//如果扩容失败
		
			printf("realloc fail!");
			exit(-1);//结束
		
		else
		
			ps->a = tmp;//将新扩容的空间地址给指针变量a
			ps->capacity = newcapacity;
		
	
	//1.初始条件
	//2.结束条件
	//3.循环条件
	int end = ps->size - 1;
	while (end >= 0)
	
		ps->a[end + 1] = ps->a[end];
		--end;
	

	ps->a[0] = x;
	ps->size++;



//打印
void SeqListPrint(SL* ps)

	int i = 0;
	for (i = 0; i < ps->size; i++)
	
		printf("%d ", ps->a[i]);
	
	printf("\\n");

 test.c文件

#define _CRT_SECURE_NO_WARNINGS
#include"SeqList.h"

//测试
void TestSeqList2()

	SL sl;
	SeqListInit(&sl);
	//尾插
	SeqListPushFront(&sl, 1);
	SeqListPushFront(&sl, 2);
	SeqListPushFront(&sl, 3);
	SeqListPushFront(&sl, 4);
	SeqListPushFront(&sl, 5);
	SeqListPushFront(&sl, 6);
	SeqListPushFront(&sl, 7);
	SeqListPushFront(&sl, 8);
	SeqListPushFront(&sl, 9);
	SeqListPushFront(&sl, 10);
	SeqListPushFront(&sl, 11);

	//打印
	SeqListPrint(&sl);


int main()

	TestSeqList2();
	return 0;

解释：

头插法和尾插一样，都是往后开辟新的内存空间，只不过一个是往前插入（开辟好的空间放老的数据，老的数据一个一个向后移动），一个是往后插入（开辟好的空间放新数据）。 

总结：

当然，对比头插和尾插，我们发现一段重复的代码，他的作用是：当看到capacity空间不够的时候，再去增容，当然我们可以不必那么麻烦，每次都要写这一大段，我们可以单拿出来封装成一个函数 SeqListCheckCapacity 来专门判断是否需要增容，然后调用它即可。

比如：

 SeqList.c文件

#include"SeqList.h"

//初始化数组为0
//要用到的数组空间也初始化为0
void SeqListInit(SL* ps)

	ps->a = NULL;
	ps->size = 0;
	ps->capacity = NULL;


//增删改查

//增

//尾插
void SeqListPushBack(SL* ps, SQDataType x)

	SeqListCheckCapacity(ps);

	ps->a[ps->size] = x;
	ps->size++;



//头插
void SeqListPushFront(SL* ps, SQDataType x)

	SeqListCheckCapacity(ps);
	//1.初始条件
	//2.结束条件
	//3.循环条件
	int end = ps->size - 1;
	while (end >= 0)
	
		ps->a[end + 1] = ps->a[end];
		--end;
	

	ps->a[0] = x;
	ps->size++;


void SeqListCheckCapacity(SL* ps)

	//满了就要扩容
	if (ps->size == ps->capacity)//当size(有效数据个数)  ==  capacity(容量空间大小),数组空间刚好被用完
	
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;//这个4是随便初始的一个值，1也可以，2也可以，不够就往后尾插
		SQDataType* tmp = (SQDataType*)realloc(ps->a, newcapacity * sizeof(SQDataType));

		if (tmp == NULL)//如果扩容失败
		
			printf("realloc fail!");
			exit(-1);//结束
		
		else
		
			ps->a = tmp;//将新扩容的空间地址给指针变量a
			ps->capacity = newcapacity;

5.2“删”

尾删

//尾删
void SeqListPopBack(SL* ps)

	assert(ps->size > 0);//断言，size <= 0，就不用删了
	ps->size--;

头删

//头删
void SeqListPopFront(SL* ps)

	assert(ps->size > 0);//断言，size <= 0，就不用删了
	int start = 1;
	while (start < ps->size)
	
		ps->a[start - 1] = ps->a[start];
		++start;
	
	ps->size--;

头尾增删实现效果：

 SeqList.h文件

#pragma once

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<assert.h>
//#define MAX_SIZE 10
typedef int SQDataType;

//可维护性增强
typedef struct SeqList

	SQDataType* a; //指向动态开辟的数组
	int size;      //有效数据的个数
	int capacity;  //容量空间大小
SL;

//初始化
void SeqListInit(SL* ps);


//增删改查接口函数

//增

//尾插
void SeqListPushBack(SL* ps, SQDataType x);
//头插
void SeqListPushFront(SL* ps, SQDataType x);

//检查是否需要扩容
void SeqListCheckCapacity(SL* ps);


//删

//尾删
void SeqListPopBack(SL* ps);
//头删
void SeqListPopFront(SL* ps);

//打印
void SeqListPrint(SL* ps);

 SeqList.c文件

#include"SeqList.h"

//初始化数组为0
//要用到的数组空间也初始化为0
void SeqListInit(SL* ps)

	ps->a = NULL;
	ps->size = 0;
	ps->capacity = NULL;


//增删改查



//增

//尾插
void SeqListPushBack(SL* ps, SQDataType x)

	SeqListCheckCapacity(ps);

	ps->a[ps->size] = x;
	ps->size++;



//头插
void SeqListPushFront(SL* ps, SQDataType x)

	SeqListCheckCapacity(ps);
	//1.初始条件
	//2.结束条件
	//3.循环条件
	int end = ps->size - 1;
	while (end >= 0)
	
		ps->a[end + 1] = ps->a[end];
		--end;
	

	ps->a[0] = x;
	ps->size++;


//检查是否需要扩容
void SeqListCheckCapacity(SL* ps)

	//满了就要扩容
	if (ps->size == ps->capacity)//当size(有效数据个数)  ==  capacity(容量空间大小),数组空间刚好被用完
	
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;//这个4是随便初始的一个值，1也可以，2也可以，不够就往后尾插
		SQDataType* tmp = (SQDataType*)realloc(ps->a, newcapacity * sizeof(SQDataType));

		if (tmp == NULL)//如果扩容失败
		
			printf("realloc fail!");
			exit(-1);//结束
		
		else
		
			ps->a = tmp;//将新扩容的空间地址给指针变量a
			ps->capacity = newcapacity;
		
	



//打印
void SeqListPrint(SL* ps)

	int i = 0;
	for (i = 0; i < ps->size; i++)
	
		printf("%d ", ps->a[i]);
	
	printf("\\n");





//删 

//尾删
void SeqListPopBack(SL* ps)

	assert(ps->size > 0);//断言，size <= 0，就不用删了
	ps->size--;


//头删
void SeqListPopFront(SL* ps)

	assert(ps->size > 0);//断言，size <= 0，就不用删了
	int start = 1;
	while (start < ps->size)
	
		ps->a[start - 1] = ps->a[start];
		++start;
	
	ps->size--;

test.c文件

#define _CRT_SECURE_NO_WARNINGS
#include"SeqList.h"

//测试

void TestSeqList1()

	SL sl;
	SeqListInit(&sl);
	//尾插
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	SeqListPushBack(&sl, 6);
	SeqListPushBack(&sl, 7);
	SeqListPushBack(&sl, 8);
	SeqListPushBack(&sl, 9);
	SeqListPushBack(&sl, 10);
	SeqListPushBack(&sl, 11);

	//打印
	SeqListPrint(&sl);


void TestSeqList2()

	SL sl;
	SeqListInit(&sl);
	//头插
	SeqListPushFront(&sl, 1);
	SeqListPushFront(&sl, 2);
	SeqListPushFront(&sl, 3);
	SeqListPushFront(&sl, 4);
	SeqListPushFront(&sl, 5);
	SeqListPushFront(&sl, 6);

	//打印
	SeqListPrint(&sl);

	//删
	SeqListPopBack(&sl);
	SeqListPopBack(&sl);
	SeqListPopBack(&sl);
	SeqListPrint(&sl);

	SeqListPopFront(&sl);
	SeqListPopFront(&sl);
	SeqListPrint(&sl);


int main()

	TestSeqList1();
	TestSeqList2();
	return 0;

当然，我们不光在处理数据的时候只会遇到对于头尾的插入删除，还会遇到对于数组中某个位置的插入删除，

5.3随机“插入”

主要思想：

  SeqList.h文件

//插入
void SeqListInert(SL* ps, int pos, SQDataType x);

 SeqList.h文件

//对于某个位置插入
void SeqListInert(SL* ps, int pos, SQDataType x)

	assert(pos < ps->size);
	SeqListCheckCapacity(ps);

	int end = ps->size - 1;
	while (end >= pos)
	
		ps->a[end + 1] = ps->a[end];
		--end;
	
	ps->a[pos] = x;
	ps->size++;

test.c文件

#define _CRT_SECURE_NO_WARNINGS
#include"SeqList.h"

//测试

void TestSeqList3()

	SL sl;
	SeqListInit(&sl);
	//尾插
	SeqListPushFront(&sl, 1);
	SeqListPushFront(&sl, 2);
	SeqListPushFront(&sl, 3);
	SeqListPushFront(&sl, 4);
	SeqListPushFront(&sl, 5);
	SeqListPushFront(&sl, 6);

	//随机插入
	SeqListInert(&sl, 1, 20);
	SeqListPrint(&sl);

int main()

	TestSeqList3();
	return 0;

5.4随机“删除”

主要思想：

   SeqList.h文件

//删除
void SeqListErase(SL* ps, int pos);

   SeqList.c文件

void SeqListErase(SL* ps, int pos)

	assert(pos < ps->size);
	int start = pos + 1;
	while (start < ps->size)
	
		ps->a[start - 1] = ps->a[start];
		++start;
	
	ps->size--;

test.c文件

#define _CRT_SECURE_NO_WARNINGS
#include"SeqList.h"

//测试

void TestSeqList3()

	SL sl;
	SeqListInit(&sl);
	//尾插
	SeqListPushFront(&sl, 1);
	SeqListPushFront(&sl, 2);
	SeqListPushFront(&sl, 3);
	SeqListPushFront(&sl, 4);
	SeqListPushFront(&sl, 5);
	SeqListPushFront(&sl, 6);

	//随机插入
	SeqListErase(&sl, 1);
	SeqListPrint(&sl);

int main()

	TestSeqList3();
	return 0;

5.5内存销毁

在打印完成后，不用了就去释放空间，销毁内存。

   SeqList.h文件

//销毁内存
void SeqListDestory(SL* ps);

   SeqList.c文件

//销毁内存
void SeqListDestory(SL* ps)

	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;

test.c文件

（每一次使用之后，以后不再使用的话，就最好在末尾加上SeqListDestory(&sl);来销毁内存）

#define _CRT_SECURE_NO_WARNINGS
#include"SeqList.h"

//测试

void TestSeqList3()

	SL sl;
	SeqListInit(&sl);
	//尾插
	SeqListPushFront(&sl, 1);
	SeqListPushFront(&sl, 2);
	SeqListPushFront(&sl, 3);
	SeqListPushFront(&sl, 4);
	SeqListPushFront(&sl, 5);
	SeqListPushFront(&sl, 6);

	//随机插入
	SeqListErase(&sl, 1);
	SeqListPrint(&sl);

	//销毁内存
	SeqListDestory(&sl);

int main()

	TestSeqList3();
	return 0;

5.6“改”

  SeqList.h文件

//改
void SeqListModify(SL* ps, int pos, SQDataType x);

 SeqList.c文件

//改
void SeqListModify(SL* ps, int pos, SQDataType x)

	assert(pos < ps->size);
	ps->a[pos] = x;

5.7“查”

  SeqList.h文件

//查找
int SeqListFind(SL* ps, SQDataType x);

 SeqList.c文件

//查找
int SeqListFind(SL* ps, SQDataType x)

	for (int i = 0; i < ps->size; ++i)
	
		if (ps->a[i] == x)
		
			return -1;
		
	
	return -1;

总结：

// 基本增删查改接口
// 顺序表初始化
void SeqListInit(SeqList* psl);
// 顺序表销毁
void SeqListDestory(SeqList* psl);
// 顺序表打印
void SeqListPrint(SeqList* psl);
// 检查空间，如果满了，进行增容
void CheckCapacity(SeqList* psl);
// 顺序表尾插
void SeqListPushBack(SeqList* psl, SLDataType x);
// 顺序表尾删
void SeqListPopBack(SeqList* psl);
// 顺序表头插
void SeqListPushFront(SeqList* psl, SLDataType x);
// 顺序表头删
void SeqListPopFront(SeqList* psl);
// 顺序表查找
int SeqListFind(SeqList* psl, SLDataType x);
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x);
// 顺序表删除pos位置的值
void SeqListErase(SeqList* psl, size_t pos);

6.顺序表相关OJ练习题

6.1原地移除元素

6.2合并两个有序数组

数据结构之顺序表(代码片段)

...找元素操作顺序表之任意位置插入顺序表之任意位置擦除线性表之查看有多少元素线性表之修改任意位置线性表之销毁空间综合SeqList.h文件内容SeqList.c文件内容前言讲完算法效率,就正式开始我们的数据结构 查看详情

线性表之顺序存储结构(顺序表)(代码片段)

目录1.线性表2.顺序存储结构(顺序表)2.1顺序表一般可以分为： 1.静态顺序表：使用定长数组存储元素 1.1静态顺序表:顺序表的大小是确定的,容量是固定的.    结论:静态顺序表不是很常量,了解就行.2.动态顺序表：... 查看详情

数据结构学习总结线性表之顺序表(代码片段)

...dquo;一对一”逻辑关系的数据，最佳的存储方式是使用线性表。那么，什么是线性表呢？线性表，全名为线性存储结构。使用线性表存储数据的方式可以这样理解，即“把所有数据用一根线儿串起来，再存储到物理空间中&r... 查看详情

数据结构线性表之顺序表arraylist(代码片段)

...在了解顺序表之前，需要先了解什么是顺序表？顺序表是线性表的一种，线性表分为顺序表和链表。其中顺序表在java中又分为数组（最简单的顺序表）和ArrayList。为什么我们称其为顺序表呢？原因顾名思义是该数据结构在逻辑... 查看详情

线性表之栈(代码片段)

栈的定义：　　一种只能在一端进行插入或删除操作的线性表被称为栈，其中允许删除或插入的一端为栈顶，另一端为栈底，栈底固定不变；　　栈的特点：先进后出，例如弹夹，先装的子弹最后才能出；　　按照存储结构可以... 查看详情

数据结构线性表之实现单链表(代码片段)

数据结构线性表之实现单链表数据结构线性表之实现单链表相关文章单链表定义单链表相关操作数据结构线性表之实现单链表相关文章数据结构线性表之概念(一)数据结构线性表之抽象基类(二)数据结构线性表之实现顺序表(三)数... 查看详情

线性表之单链表(代码片段)

在学完线性表之后，总结一下顺序表的优缺点优点无须为元素之间的逻辑结构增添额外的储存空间，自成一体。随机存取，十分方便。缺点空间利用率不高，容易造成“碎片”。插入删除操作需要移动大量的元素。当线性... 查看详情

数据结构之线性表之顺序存储java实现(代码片段)

文章目录线性表的定义线性表的基本运算线性表的存储之顺序存储定义线性表添加元素查找元素删除元素打印线性表实现的完整代码测试一下线性表的定义线性表的逻辑特征：①有且仅有一个称为开始元素的a1，她没有前... 查看详情

03线性表之链表(代码片段)

肚子饿了就要吃  ~  嗝 ———路飞 1.本章重点链表表示和实现（单链表+双链表）链表的常见OJ题顺序表和链表的区别和联系2.为什么需要链表引子：顺序表的问题及思考(1)动态顺序表特点：插入数据，... 查看详情

数据结构线性表之实现单循环链表(代码片段)

数据结构线性表之实现单循环链表数据结构线性表之实现单循环链表相关文章单循环链表单循环链表定义数据结构线性表之实现单循环链表相关文章数据结构线性表之概念(一)数据结构线性表之抽象基类(二)数据结构线性表之实... 查看详情

线性表之顺序存储-顺序表(代码片段)

顺序表的操作[x]向有序顺序表插入一个元素[x]顺序表的冒泡排序[x]顺序表的删除操作[x]顺序表中元素的查找[x]顺序表的逆置[x]删除顺序表中的相同元素[x]向顺序表的指定位置插入元素[x]打印顺序表顺序表的存储结构#definemaxsize100/... 查看详情

数据结构——线性表之顺序表篇(代码片段)

...码顺序表小结前言在介绍顺序表之前我们先简单了解一下线性表：线性表是n个具有相同特性的数据元素的有限序列，在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表... 查看详情

线性表之链表(代码片段)

单链表也是一种链式存取的线性表，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，以next指针指向下一个节点而链接起来，相比于顺序表，链表有着快速增加，删除节点的优势，其节点... 查看详情

数据结构线性表循环链表之约瑟夫环(代码片段)

（一）前提41个人报数，1-3，当谁报数为3，谁就去嗝屁。现在获取他们嗝屁的顺序（二）实现结构顺序：3->1->5->2->4 （三）代码实现#define_CRT_SECURE_NO_WARNINGS#include<stdio.h>#include<stdlib.h>#include<time.h>#defineOK1#... 查看详情

数据结构学习总结线性表之单链表(代码片段)

   一，回忆链表 　链表，别名链式存储结构或单链表，用于存储逻辑关系为"一对一"的数据。与顺序表不同，链表不限制数据的物理存储状态，换句话说，使用链表存储的数据元素，其物理存储位置是随机的。&nbs... 查看详情

线性链表之顺序表

/* @content线性链表之顺序表 @date2017-3-211:06 @authorJohnnyZen *//*线性表  顺序表  链式表[带头指针/不带头指针]   单链表  循环单链表 双向链表循环双链表   ADT& 查看详情

线性链表之顺序表

顺序表中数据元素的存储地址是其序号的线性函数，只要确定了存储顺序表的起始地址(即基地址)，计算任意一个元素的存储地址的时间是相等的，具有这一特点的存储结构称为[随机存储]。使用的基本数据结构:数组特点：顺序... 查看详情

数据结构与算法-线性表之循环链表(代码片段)

前言：前面几篇介绍了线性表的顺序和链式存储结构，其中链式存储结构为单向链表（即一个方向的有限长度、不循环的链表），对于单链表，由于每个节点只存储了向后的指针，到了尾部标识就停止了向后链的操作。也就是说... 查看详情