7_线性表的顺序存储结构

顺序存储结构

顺序存储定义

线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。

在C语言中可以用一维数组来实现顺序存储结构

存储空间的起始位置：数组node

线性表的最大容量：数组长度MAXSIZE

线性表的当前长度：length

获取元素操作

判断线性表是否合法

判断位置是否合法

直接通过数组下标的方式获取元素

插入元素操作

插入元素算法

判断线性表是否合法

判断插入位置是否合法

把最后一个元素到插入位置的元素后移一个位置

将新元素插入

线性表长度加1

删除元素操作

删除元素算法

判断线性表是否合法

判断删除位置是否合法

将元素取出

将删除位置后的元素分别向前移动一个位置

线性表长度减1

创建可复用顺序线性表

SeqList.h

#pragma once
#include <stdio.h>

typedef void SeqList; //此处为什么要声明为void，而在实现时的实际类型是typedef unsigned int TSeqListNode，因为封装。
typedef void SeqListNode;

/*
该方法用于创建并且返回一个空的线性表
*/
SeqList* SeqList_Create(int capacity);

/*
该方法用于销毁一个线性表SeqList
*/
void SeqList_Destory(SeqList* list);

/*
该方法用于将一个线性表SeqList中的所有元素清空
使得线性表回到创建时的初始状态
*/
void SeqList_Clear(SeqList* list);

/*
该方法用于返回一个线性表SeqList中的所有元素个数
*/
int SeqList_Length(SeqList* list);

int SeqList_Capacity(SeqList* list);

/*
该方法用于向一个线性表SeqList的pos位置处插入新元素node
返回值为1表示插入成功，0表示插入失败
*/
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);

/*
该方法用于获取一个线性表SeqList的pos位置处的元素
返回值为pos位置处的元素，NULL表示获取失败
*/
SeqListNode* SeqList_Get(SeqList* list, int pos);

/*
该方法用于删除一个线性表SeqList的pos位置处的元素
返回值为被删除的元素，NULL表示删除失败
*/
SeqListNode* SeqList_Delete(SeqList* list, int pos);

SeqList.cpp

#include "SeqList.h"
#include <stdio.h>

typedef unsigned int TSeqListNode;  //顺序表的元素类型
//为什么是unsigned int? 兼容int和char等,指针也是4个字节.
typedef struct _tag_SeqList //顺序表的类型
{
	int capacity; //最大容量
	int length; //占用的长度
	TSeqListNode* node; //为什么用指针？不用数组?
	//可以动态指定数组的长度
}TSeqList;

SeqList* SeqList_Create(int capacity) { //时间复杂度 O(1)
	TSeqList* ret = NULL;

	if (capacity >= 0) {
		ret = (TSeqList*)malloc(sizeof(TSeqList) + sizeof(TSeqListNode)*capacity );
		//此处的内存分配见图示
	}

	if (ret != NULL) {
		ret->capacity = capacity;
		ret->length = 0; 
		ret->node = (TSeqListNode*)(ret + 1);
	}

	return ret;
}

void SeqList_Destory(SeqList* list) //O(1)
{
	free(list);
}

void SeqList_Clear(SeqList* list) { //O(1)
	TSeqList* sList = (TSeqList*)list;

	if (sList) {
		sList->length = 0; //实际长度归0
	}
}

int SeqList_Length(SeqList* list) { //O(1)
	int ret = -1;

	TSeqList* sList = (TSeqList*)list;
	if (sList) {
		ret = sList->length;
	}

	return ret;
}

int SeqList_Capacity(SeqList* list) { //O(1)
	int ret = -1;

	TSeqList* sList = (TSeqList*)list;
	if (sList) {
		ret = sList->capacity;
	}

	return ret;
}

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos) { //O(n)
	TSeqList* sList = (TSeqList*)list;

	int ret = (sList != NULL);
	int i = 0;

	ret = ret && (sList->length + 1 <= sList->capacity); //不能超过最大容量
	ret = ret && (0 <= pos);

	if (ret) {
		if (pos >= sList->length) { //小修正：如果传入的要插入的位置为10，实际长度为5， 那么插入到5位置.
			pos = sList->length;
		}

		for (i = sList->length; i > pos; i--) {
			sList->node[i] = sList->node[i - 1];
		}

		sList->node[pos] = (TSeqListNode)(node); //将元素的地址值 强制转换 为 unsiged int, 存入pos位置处。

		sList->length++;
	}

	return ret;
}

SeqListNode* SeqList_Get(SeqList* list, int pos) { //O(1)
	TSeqList* sList = (TSeqList*)list;
	SeqListNode* ret = NULL;

	if ((sList != NULL) && (0 <= pos) && (pos < sList->length)) {
		ret = (SeqListNode*)(sList->node[pos]); //元素中存储的是地址值，将地址值（整形）强转为指针。
	}
	
	return ret;
}

SeqListNode* SeqList_Delete(SeqList* list, int pos) { //O(n)
	TSeqList* sList = (TSeqList*)(list);
 	
	SeqListNode* ret = SeqList_Get(list, pos);
	int i = 0;
	if (ret) {
		for (i = pos + 1; i < sList->length; i++)
		{
			sList->node[i - 1] = sList->node[i];
		}

		sList->length--;
	}

	return ret;
}

main.c

// ConsoleApplication1.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "SeqList.h"

void func() {
	SeqList* list = SeqList_Create(5);

	int i = 0;
	int j = 1;
	int k = 2;
	int x = 3;
	int y = 4;
	int z = 5;

	int index = 0;

	SeqList_Insert(list, &i, 0);
	SeqList_Insert(list, &j, 0);
	SeqList_Insert(list, &k, 0);
	SeqList_Insert(list, &x, 0);
	SeqList_Insert(list, &y, 0);
	SeqList_Insert(list, &z, 0);

	for (index = 0; index < SeqList_Length(list); index++)
	{
		int* p = (int*)(SeqList_Get(list, index));
		 
		printf("%d\n", *p);
	}

	printf("\n");

	while (SeqList_Length(list) > 0 )
	{
		int* p = (int*)SeqList_Delete(list, 0);

		printf("%d\n", *p);
	}

	SeqList_Destory(list);
}

int main()
{
	func();
	
	getchar();

    return 0;
}

小结

优点：

无需为线性表中的逻辑关系增加额外的空间 （就是一个数组）

可以快速的获取表中合法位置的元素

缺点：

插入和删除操作需要移动大量元素

当线性表长度变化较大时难以确定存储空间的容量

----------------------2020.07