顺序表Note

最新推荐文章于 2024-05-01 21:54:30 发布

新人如附件

最新推荐文章于 2024-05-01 21:54:30 发布

阅读量88

点赞数 1

分类专栏：数据结构文章标签：数据结构 c语言

本文链接：https://blog.csdn.net/qq_42957563/article/details/118927684

版权

数据结构专栏收录该内容

11 篇文章 0 订阅

订阅专栏

顺序表实现代码学习：

数据结构 || c语言顺序表_Template Code-CSDN博客

顺序表（动态存储容量）

#include <stdio.h>
#include<stdlib.h>
#include <stdbool.h>
#define InitSize 10	//顺序表的初始长度(动态存储时)

typedef int ElemType;


//动态容量

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

void InitList(SeqList* L) {
	//用malloc函数申请一片连续的存储空间
	//malloc函数：线性表02视频16min左右有过说明
	(*L).data = (int*)malloc(InitSize * sizeof(int));
	(*L).length = 0;
	(*L).Maxsize = InitSize;

	for (int i = 0; i < (*L).Maxsize; i++) {
		(*L).data[i] = 0;		//顺序表内所有数据元素默认初始值
	}
}

//能够动态数组的长度
void IncreaseSize(SeqList* L, int len) {
	int* p = (int*)malloc(((*L).Maxsize + len) * sizeof(int));

	for (int i = 0; i < (*L).length; i++) {
		p[i]= (*L).data[i];	//将数据复制到新区域

	}
	(*L).Maxsize = (*L).Maxsize + len;	//将顺序表的最大长度增加len
	free((*L).data);
	(*L).data = p;  //数组代表数组的首地址
}

//基本操作--插入一个数
bool ListInsert(SeqList* L, int i, int* e) {
	/*printf("%d,%d,%d", (*L).length, i, *e);*/

	if (i<1 || i>((*L).length + 1)) {
		return false;
	}
	if ((*L).length >= (*L).Maxsize) {
		IncreaseSize(L, (*L).length + 1);
	}

	for (int j = (*L).length; j >= i; j--)
		(*L).data[j] = (*L).data[j - 1];
	(*L).data[i - 1] = *e;
	(*L).length++;
	return true;
}

//基本操作--删除一个数
bool ListDelete(SeqList* L, int i, int* e) {

	if (i<1 || i>(*L).length)
		return false;
	*e = (*L).data[i - 1];
	for (int j = i; j < (*L).length; j++)
		(*L).data[j - 1] = (*L).data[j];
	(*L).length--;
	return true;

}

//基本操作--按位查找，返回值
int GetElem(SeqList* L, int i) {
	return (*L).data[i - 1];
}

//基本操作--按值查找，返回位
int LocateElem(SeqList* L, ElemType e) {
	for (int i = 0; i < (*L).length; i++) {
		if ((*L).data[i] == e)
			return i + 1;
	}
	return 0;
}


int main() {
	SeqList L;	//申明一个顺序表
	InitList(&L);	//初始化

	printf("%d\n", L.Maxsize);
	//c语言不支持引用，得使用指针，从而使函数中的数值修改被存储

	L.length = L.Maxsize;//先定义一下，测试一下插入是否正常

	//动态扩充顺序表两个数据
	IncreaseSize(&L, 2);
	printf("%d\n", L.Maxsize);

	int e = 9;
	int index = 11;

	if (ListInsert(&L, index, &e))
		printf("\nok,%d\n", e);
	else
		printf("no\n");

	printf("%d\n", GetElem(&L, index));
	printf("%d\n", GetElem(&L, index-1));

	printf("%d\n", LocateElem(&L, e));


	return 0;
}

顺序表（静态存储空间）

#include <stdio.h>
#include <stdbool.h>
#define MaxSize 10 //定义最大长度(静态存储时)

typedef int ElemType;

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

}SqList;		//顺序表的类型定义

//基本操作--初始化一个顺序表
void InitList(SqList *L) {
	for (int i = 0; i < MaxSize; i++)
		(*L).data[i] = 6;		//顺序表内所有数据元素默认初始值
		(*L).length = 0;	//顺序表初始长度为0
}

//基本操作--插入一个数
bool ListInsert(SqList* L, int i, int *e) {
	printf("%d,%d,%d", (*L).length, i, *e);

	if (i<1 || i>((*L).length + 1)) {
		return false;
	}
		
	if ((*L).length >= MaxSize) {
		return false;
	}
		
	for (int j = (*L).length; j >= i; j--)
		(*L).data[j] = (*L).data[j - 1];
	(*L).data[i - 1] = *e;
	(*L).length++;
	return true;
}

//基本操作--删除一个数
bool ListDelete(SqList* L, int i,int *e) {

	if (i<1 || i>(*L).length)
		return false;
	*e = (*L).data[i - 1];
	for (int j = i; j < (*L).length; j++)
		(*L).data[j - 1] = (*L).data[j];
	(*L).length--;
	return true;

}

//基本操作--按位查找，返回值
int GetElem(SqList* L, int i) {
	return (*L).data[i - 1];
}

//基本操作--按值查找，返回位
int LocateElem(SqList* L, ElemType 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);	//初始化
	int e = 9;
	L.length = 8;//先定义一下，测试一下插入是否正常
	if(ListInsert(&L, 3, &e))
		printf("\nok,%d\n",e);
	else
		printf("no\n");

	printf("%d\n", GetElem(&L, 3));
	printf("%d\n", GetElem(&L, 2));

	printf("%d\n", LocateElem(&L, e));

	return 0;
}

C语言知识点拾遗：

1.C语言指针

SDataType  *array;

2.assert()

assert(seqlist != NULL);

3.- >指向结构体的指针调用结构体中的数据

seqlist->array

4.*数据类型

seqlist->array = (SDataType*)malloc(sizeof(SDataType)*capacity);

当a声明的类型是int *时，a中存储的是一个存储单元的地址，而该存储单元中存储的数据是一个整数数值；

*：取某地址的值（数据内容），运算符后通常跟一个地址

&：取某数据（变量）的地址，运算符后通常跟一个变量

5.malloc()

void* malloc (size_t size);

6.C 函数引用参数传递Error——存在正文时不允许未命名的原型参数

_MCNS_37的博客-CSDN博客

顺序表初始化时，同样的功能、结构体

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


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

}SqList;		//顺序表的类型定义

C语言中

//c语言内要
void InitList(SqList *L) {//-------------------------------------
	for (int i = 0; i < MaxSize; i++)
		(*L).data[i] = 10;		//顺序表内所有数据元素默认初始值
		(*L).length = 0;	//顺序表初始长度为0
}

int main() {
	SqList L;	//申明一个顺序表
	//L= {data = [],	0};
	InitList(&L);	//初始化--------------------------------------
    return 0;
}

C++中

//C++内
//基本操作--初始化一个顺序表
void InitList(SqList& L) {
	for (int i = 0; i < MaxSize; i++)
		L.data[i] = 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;
}