Data Structures（一）顺序表

线性表：在数据元素的非空有限集合中，除第一个元素无直接前驱、最后一个元素无直接后继，集合中其余每个数据元素都有唯一直接前驱唯一直接后继。

线性表有顺序存储结构和链式存储结构两种存储方式。含有大量类型相同记录的线性表称为文件或数据对象。但是一个线性表中的数据元素必须属于同一个数据对象。因此线性表中相邻元素存在序偶关系。

线性表的特点：

1、同一性：同一数据类型

2、有穷性：有限数据元素

3、有序性：相邻元素存在序偶关系

本章重点：顺序表

n个相同类型的数据元素的有限序列，除第一个元素无直接前驱、最后一个元素无直接后继，集合中其余每个数据元素都有唯一直接前驱唯一直接后继，数据元素是一对一的关系。

#pragma once

//线性表的顺序存储结构------顺序表 
typedef size_t DataType;
#define MAXSIZE 20

typedef struct SeqList
{
	DataType arr[MAXSIZE];
	DataType size;
}SeqList;

void InitList(SeqList* list); //初始化
DataType Size(SeqList* list); //顺序表的大小
DataType FindData(SeqList* list, DataType pos); //查找第i个元素
void printList(SeqList* list);//输出顺序表
void insertBack(SeqList* list, DataType x); //尾插
void insertFront(SeqList* list, DataType x); //头插
void popBack(SeqList* list); //尾删
void popFront(SeqList* list); //头删
void del(SeqList* list, DataType pos); //删除
void insert(SeqList* list, DataType pos, DataType x); //插入
void Modify(SeqList* list, DataType pos, DataType x); //修改
void SeqListRemoveAll(SeqList *list, DataType x);//删除所有值为x的数据  要求时间复杂度为n 空间复杂度为1


void InitList(SeqList* list)
{
	memset(list->arr, 0, sizeof(DataType)*MAXSIZE);
	list->size = 0;
}

void printList(SeqList* list)
{
	assert(list);
	for (size_t i = 0; i < list->size; i++)
	{
		cout << list->arr[i] << " ";
	}
	cout << endl;
}

DataType Size(SeqList* list)
{
	return list->size;
}

DataType FindData(SeqList* list, DataType pos)
{
	assert(list);
	if (pos > list->size || pos < 0)
	{
		cout << "超出索引" << endl;
	}
	return list->arr[pos - 1];
}

void insertBack(SeqList* list, DataType x)
{
	if (list->size >= MAXSIZE)
	{
		cout << "数组已满" << endl;
		return;
	}
	else
	{
		list->arr[list->size] = x;
		list->size++;
	}
}

void insertFront(SeqList* list, DataType x)
{
	if (list->size >= MAXSIZE)
	{
		cout << "数组已满" << endl;
		return;
	}
	else
	{
		size_t end = list->size;
		while (end > 0)
		{
			end--;
			list->arr[end + 1] = list->arr[end];
		}
		list->arr[0] = x;
		list->size++;
	}
}

void popBack(SeqList* list)
{
	if (list->size == 0)
	{
		cout << "数组为空" << endl;
	}
	list->arr[list->size - 1] = 0;
	list->size--;
}

void popFront(SeqList* list)
{
	if (list->size == 0)
	{
		cout << "数组为空" << endl;
	}

	for (size_t i = 0; i < list->size; i++)
	{
		list->arr[i] = list->arr[i + 1];
	}
	list->size--;
}

void del(SeqList* list, DataType pos)
{
	if (list->size == 0)
	{
		cout << "数组为空" << endl;
	}
	else if (pos > list->size || pos < 0)
	{
		cout << "删除位置不合法" << endl;
	}
	else
	{
		for (size_t i = pos - 1; i < list->size; i++)
		{
			list->arr[i] = list->arr[i + 1];
		}
		list->size--;
	}
}
void insert(SeqList* list, DataType pos, DataType x)
{
	if (list->size >= MAXSIZE)
	{
		cout << "数组已满" << endl;
	}
	else if (pos > list->size + 1 || pos < 0)
	{
		cout << "插入位置不合法" << endl;
	}
	else
	{
		size_t end = list->size;
		while (end > pos - 1)
		{
			end--;
			list->arr[end + 1] = list->arr[end];
		}
		list->arr[pos - 1] = x;
		list->size++;
	}
}
void Modify(SeqList* list, DataType pos, DataType x)
{
	assert(list);
	if (pos > list->size || pos < 0)
	{
		cout << "修改位置不合法" << endl;
	}
	list->arr[pos - 1] = x;
}

void SeqListRemoveAll(SeqList *list, DataType x)
{
	assert(list);
	size_t index = 0;
	size_t i = 0;
	size_t count = 0;
	for (; i < list->size; i++)
	{
		if (list->arr[i] != x)
		{
			list->arr[index] = list->arr[i];
			index++;
		}
		else
		{
			count++;
		}
	}
	list->size -= count;
}


void testSeqList()
{
	SeqList list;
	InitList(&list);
	insertBack(&list, 1);
	insertBack(&list, 2);
	insertBack(&list, 3);
	insertBack(&list, 4);
	insertFront(&list, 7);
	insertFront(&list, 8);
	insertFront(&list, 9);
	popBack(&list);
	popBack(&list);
	popFront(&list);
	popFront(&list);
	del(&list, 2);
	insert(&list, 3, 9);
	Modify(&list, 3, 8);
	insertBack(&list, 1);
	insertBack(&list, 2);
	insertBack(&list, 3);
	insertBack(&list, 4);
	insertBack(&list, 1);
	insertBack(&list, 2);
	insertBack(&list, 3);
	insertBack(&list, 4);
	SeqListRemoveAll(&list, 2);
	printList(&list);
	cout << Size(&list) << endl;
	cout << FindData(&list, 2) << endl;
}

 

//顺序表的动态存储----动态顺序表

typedef struct ma_SeqList
{
	DataType *array;   //数据块指针
	size_t _size;     //当前有效数据量
	size_t _capacity; //容量
}ma_SeqList;

//初始化
void Init_ma_List(ma_SeqList* list, size_t capacity)
{
	assert(list&&capacity > 0);
	list->array = (DataType*)malloc(sizeof(DataType)*capacity);
	list->_size = 0;
	list->_capacity = capacity;
}

//扩容
void checkCapacity(ma_SeqList* list)
{
	if (list->_size >= list->_capacity)
	{
		DataType* a = (DataType*)realloc(list->array, sizeof(DataType)*list->_capacity * 2);
		assert(a);
		list->array = a;
		list->_capacity *= 2;
	}
}
//尾插
void insert_ma_Back(ma_SeqList* list, DataType x)
{
	assert(list);
	checkCapacity(list);
	list->array[list->_size] = x;
	list->_size++;
}