线性结构之顺序表

最新推荐文章于 2023-06-25 09:36:43 发布

PHONER'S NUHC

最新推荐文章于 2023-06-25 09:36:43 发布

阅读量250

点赞数 1

分类专栏： DS

本文链接：https://blog.csdn.net/PNUHC/article/details/90247243

版权

DS 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

1. 什么是线性结构？

2. 线性结构中都包含什么内容？

3. 什么是顺序表？顺序表的分类？

4. 完成动态顺序表的以下操作：

// 动态的顺序表
typedef int DataType;
typedef struct SeqList
{
DataType* _array;
int _capacity; // 顺序表的总大小
int _size; // 顺序表中有效元素的个数
}SeqList, PSeq;
//typedef struct SeqList SeqList;
//typedef struct SeqList PSeqList;
// 顺序表的初始化
void SeqListInit(PSeq ps, int capacity);
// 在顺序表的尾部插入值为data的元素
void SeqListPushBack(PSeq ps, DataType data);
// 删除顺序表最后一个元素
void SeqListPopBack(PSeq ps);
// 在顺序表的头部插入值为data的元素
void SeqListPushFront(PSeq ps, DataType data);
// 删除顺序表头部的元素
void SeqListPopFront(PSeq ps);
// 在顺序表pos位置插入值为data的元素
void SeqListInsert(PSeq ps, int pos, DataType data);
// 删除顺序表中pos位置上的元素
void SeqListErase(PSeq ps, int pos);
// 在顺序表中查找值为data的元素，找到返回该元素在顺序表中的下标，否则返回-1
int SeqListFind(PSeq ps, DataType data);
// 检测顺序表是否为空，如果为空返回非0值，非空返回0
int SeqListEmpty(PSeq ps);
// 返回顺序表中有效元素的个数
int SeqListSize(PSeq ps);
// 返回顺序表的容量大小
int SeqListCapacity(PSeq ps);
// 将顺序表中的元素清空
void SeqListClear(PSeq ps);
// 删除顺序表中第一个值为data的元素
void SeqListRemove(PSeq ps, DataType data);
// 销毁顺序表
void SeqListDestroy(PSeq ps);
// 顺序表的扩容
void CheckCapacity(PSeq ps);

什么是线性结构？

总的来说，线性结构是一个有序数据元素的集合。
满足以下特点：
集合中必存在唯一“第一个元素”；
集合中必存在唯一“最后一个元素”；
除了最后一个元素，所有元素有存在唯一“后继节点”；
除了第一个元素，所有元素都存在唯一“ 前趋节点”。

线性结构中都包含什么内容？

常见的线性结构：顺序表、链表、栈、队列、字符串等。

什么是顺序表？顺序表的分类？

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

完成动态顺序表的以下操作：

我的顺序表完整代码如下：

seqlist.h:

#define _CRT_SECURE_NO_WARNINGS 1
#include<malloc.h>
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>

# pragma once
typedef int DataType;
typedef struct seqlist
{
	DataType* _array;
	int _size;
	int _capacity;
}SeqList, *PSeq;
//typedef struct SeqList SeqList; 
//typedef struct SeqList* PSeqList; 

// 顺序表的初始化 
void SeqListInit(PSeq ps, int capacity);

// 在顺序表的尾部插入值为data的元素 
void SeqListPushBack(PSeq ps, DataType data);

// 删除顺序表最后一个元素 
void SeqListPopBack(PSeq ps);

// 在顺序表的头部插入值为data的元素 
void SeqListPushFront(PSeq ps, DataType data);

// 删除顺序表头部的元素 
void SeqListPopFront(PSeq ps);

// 在顺序表pos位置插入值为data的元素 
void SeqListInsert(PSeq ps, int pos, DataType data);

// 删除顺序表中pos位置上的元素 
void SeqListErase(PSeq ps, int pos);

// 在顺序表中查找值为data的元素，找到返回该元素在顺序表中的下标，否则返回-1 
int SeqListFind(PSeq ps, DataType data);

// 检测顺序表是否为空，如果为空返回非0值，非空返回0 
int SeqListEmpty(PSeq ps);

// 返回顺序表中有效元素的个数 
int SeqListSize(PSeq ps);

// 返回顺序表的容量大小 
int SeqListCapacity(PSeq ps);

// 将顺序表中的元素清空 
void SeqListClear(PSeq ps);

// 删除顺序表中第一个值为data的元素 
void SeqListRemove(PSeq ps, DataType data);

// 销毁顺序表 
void SeqListDestroy(PSeq ps);

// 顺序表的扩容 
void CheckCapacity(PSeq ps);

//打印顺序表
void SeqListPrint(PSeq ps);

seqlist.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"seqlist.h"


// 顺序表的初始化 
void SeqListInit(PSeq ps, int capacity)
{
	assert(ps);
	ps->_array = (DataType*)malloc(sizeof(DataType)* capacity);
	if (NULL == ps->_array)
	{
		assert(0);
		return;
	}
	//ps->_array
	ps->_capacity = capacity;
	ps->_size = 0;
}

// 在顺序表的尾部插入值为data的元素 
void SeqListPushBack(PSeq ps, DataType data)
{
	assert(ps);
	CheckCapacity(ps);
	ps->_array[ps->_size] = data;
	ps->_size++;
}

// 删除顺序表最后一个元素 
void SeqListPopBack(PSeq ps)
{
	assert(ps);
	if (SeqListEmpty(ps))/0?
	{
		return;
	}
	else
	{
		ps->_size--;
	}
}

// 在顺序表的头部插入值为data的元素
void SeqListPushFront(PSeq ps, DataType data)
{
	assert(ps);
	CheckCapacity(ps);
	for (int i = (ps->_size - 1); i >= 0; i--)
	{
		ps->_array[i + 1] = ps->_array[i];
	}
	ps->_array[0] = data;
	ps->_size++;
}

// 删除顺序表头部的元素
void SeqListPopFront(PSeq ps)
{
	assert(ps);
	if (SeqListEmpty(ps))//0?
	{
		return;
	}
	else
	{
		for (int i = 1; i < ps->_size; i++)
		{
			ps->_array[i - 1] = ps->_array[i];
		}
		ps->_size--;
	}
}

// 在顺序表pos位置插入值为data的元素
void SeqListInsert(PSeq ps, int pos, DataType data)
{
	assert(ps);
	if (pos < 0 || pos > ps->_size)
	{
		return;
	}
	CheckCapacity(ps);
	for (int i = ps->_size - 1; i >= pos; i--)
	{
		ps->_array[i + 1] = ps->_array[i];
	}
	ps->_array[pos] = data;
	ps->_size++;
}

// 删除顺序表中pos位置上的元素
void SeqListErase(PSeq ps, int pos)
{
	assert(ps);
	if (pos < 0 || pos > ps->_size)
		return;
	else
	{
		for (int i = pos; i < (ps->_size - 1); i++)
		{
			ps->_array[i] = ps->_array[i + 1];
		}
		ps->_size--;
	}
}

// 在顺序表中查找值为data的元素，找到返回该元素在顺序表中的下标，否则返回-1 
int SeqListFind(PSeq ps, DataType data)
{
	assert(ps);
	/*if (SeqListEmpty(ps))
		return -1;
	else*/
	{
		for (int i = 0; i < ps->_size; i++)
		{
			if (ps->_array[i] == data)
				return i;
		}
		return -1;
	}
}

// 检测顺序表是否为空，如果为空返回非0值，非空返回0 
int SeqListEmpty(PSeq ps)
{
	assert(ps);
	return 0 == ps->_size;重点理解
}

// 返回顺序表中有效元素的个数
int SeqListSize(PSeq ps)
{
	assert(ps);
	return ps->_size;
}

// 返回顺序表的容量大小 
int SeqListCapacity(PSeq ps)
{
	assert(ps);
	return ps->_capacity;
}

// 将顺序表中的元素清空
void SeqListClear(PSeq ps)
{
	assert(ps);
	ps->_size = 0;
}

// 删除顺序表中第一个值为data的元素
void SeqListRemove(PSeq ps, DataType data)
{
	assert(ps);
	//SeqListErase(ps, SeqListFind(ps, data));
	if (SeqListEmpty(ps))
		return;
	else
	{
		int pos = 0;
		for (int i = 0; i < ps->_size; i++)
		{
			if (ps->_array[i] == data)
			{
				pos = i;
				break;
			}
		}
		for (int i = pos + 1; i < ps->_size; i++)
		{
			ps->_array[i - 1] = ps->_array[i];
		}
		ps->_size--;
	}
}

// 销毁顺序表
void SeqListDestroy(PSeq ps)
{
	assert(ps);
	if (ps->_array)
	{
		free(ps->_array);
		ps->_array = NULL;
		ps->_size = 0;
		ps->_capacity = 0;
	}
}

// 顺序表的扩容 
void CheckCapacity(PSeq ps)
{
	assert(ps);
	if (ps->_capacity == ps->_size)
	{
		DataType* pTmp = (DataType*)malloc(sizeof(DataType)*(ps->_capacity * 2));
		if (NULL == pTmp)
		{
			assert(0);
			return;
		}
		else
		{
			for (int i = 0; i < ps->_size; i++)
				pTmp[i] = ps->_array[i];
			free(ps->_array);
			ps->_array = pTmp;
			ps->_capacity = ps->_capacity * 2;
		}
	}
}

//打印顺序表
void SeqListPrint(PSeq ps)
{
	assert(ps);
	for (int i = 0; i < ps->_size; i++)
	{
		printf("%d ", ps->_array[i]);
	}
	printf("\n");
}

//测试顺序表
//int SeqListTest()
int main()
{
	int pos = -1;
	SeqList s ;
	SeqListInit(&s, 10);
	SeqListPushBack(&s, 0);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 5);
	SeqListPrint(&s);
	SeqListPopBack(&s);
	SeqListPrint(&s);
	SeqListPushFront(&s, 10);
	SeqListPrint(&s);
	SeqListPopFront(&s);
	SeqListPrint(&s);
	SeqListInsert(&s, 3, 10);
	SeqListPrint(&s);
	SeqListErase(&s, 1);
	SeqListPrint(&s);
	pos = SeqListFind(&s, 10);
	printf("pos==%d\n", pos);
	int empty = SeqListEmpty(&s);
	printf("empty==%d\n", empty);
	SeqListPrint(&s);
	int num = SeqListSize(&s);
	printf("num==%d\n", num);
	int capacity = SeqListCapacity(&s);
	printf("capacity==%d\n", capacity);
	SeqListRemove(&s, 10);
	SeqListPrint(&s);
	SeqListPushFront(&s, 1);
	SeqListPushFront(&s, 1);
	SeqListPushFront(&s, 1);
	SeqListPushFront(&s, 1);
	SeqListPushFront(&s, 1);
	SeqListPushFront(&s, 1);
	SeqListPrint(&s);
	CheckCapacity(&s);
	int capacity1 = SeqListCapacity(&s);
	printf("capacity1==%d\n", capacity1);
	SeqListClear(&s);
	SeqListPrint(&s);
	SeqListDestroy(&s);

	system("pause");
	return 0;
}

然后我的测试结果如图：
在这里插入图片描述

PHONER'S NUHC

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
线性结构之顺序表

1. 什么是线性结构？2. 线性结构中都包含什么内容？3. 什么是顺序表？顺序表的分类？4. 完成动态顺序表的以下操作：// 动态的顺序表typedef int DataType;typedef struct SeqList{DataType* _array;int _capacity; // 顺序表的总大小int _size; // 顺序表中有效元素的个数}SeqList...
复制链接

扫一扫