线性结构之顺序表

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. 什么是线性结构?

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

  1. 线性结构中都包含什么内容?

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

  1. 什么是顺序表?顺序表的分类?

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

  1. 完成动态顺序表的以下操作:

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

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;
}

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

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值