数据结构 线性结构--顺序表

1. 什么是线性结构？
   线性结构是n个具有相同特性的数据元素的有限序列,也称为线性表。
2. 线性结构中都包含什么内容？
   线性结构是一种在实际中广泛使用的数据结构，常见的线性结构：顺序表、链表、栈、队列、字符串…
3. 什么是顺序表？顺序表的分类？
   顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改.
4. 动态顺序表
   顺表要实现的功能:

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <malloc.h>
typedef int DataType;
typedef struct Seqlist {
	int* arr;
	int capacity;
	int size;
}Seqlist,*PSeq;
typedef struct Seqlist Seqlist;
typedef struct Seqlist* PSeq;
#define SIZE 5

// 顺序表的初始化 
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);

程序代码:

#include "sqelist.h"

void SeqlistPrint(PSeq ps) {
	assert(ps);
	for (int i = 0; i < ps->size; ++i) {
		printf("%d", ps->arr[i]);
	}
	printf("\n");
}

void SeqlistInit(PSeq ps, int capacity) {
	ps->arr = (int*)malloc(capacity * sizeof(int));
	if (ps == NULL) {
		assert(0);
		return;
	}
	ps->capacity = capacity;
	ps->size = 0;
}

void SeqlistPushBack(PSeq ps,DataType data) {
	assert(ps);
	if (ps->size == ps->capacity) {
		CheckCapacity(ps);
	}
	ps->arr[ps->size] = data;
	++ps->size;
}

void SeqlistPopBack(PSeq ps) {
	assert(ps);
	if (SeqlistEmpty(ps)) {
		return;
	}
	--ps->size;
}

void SeqlistPushFront(PSeq ps, DataType data) {
	assert(ps);
	if (ps->size == ps->capacity) {
		CheckCapacity(ps);
	}
	for (int i = ps->size; i > 0; --i) {
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[0] = data;
	++ps->size;
}

void SeqlistPopFront(PSeq ps) {
	assert(ps);
	if (SeqlistEmpty(ps)) {
		return;
	}
	for (int i = 0; i < ps->size; ++i) {
		ps->arr[i] = ps->arr[i + 1];
	}
	--ps->size;
}

void SeqlistInsert(PSeq ps, int pos, DataType data) {
	assert(ps);
	if (pos < 0 || pos > ps->size) {
		return;
	}
	if (ps->size == ps->capacity) {
		CheckCapacity(ps);
	}
	for (int i = ps->size; i > pos; --i) {
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = data;
	++ps->size;
}

void SeqlistErase(PSeq ps, int pos) {
	assert(ps);
	if (pos > ps->size||pos < 0) {
		return;
	}
	for (int i = pos; i < ps->size - 1; ++i) {
		ps->arr[i] = ps->arr[i + 1];
	}
	--ps->size;
}

int SeqlistFind(PSeq ps, DataType data) {
	assert(ps);
	for (int i = 0; i < ps->size; ++i) {
		if (ps->arr[i] == data) {
			return i;
		}
	}
	return -1;
}

int SeqlistEmpty(PSeq ps) {
	assert(ps);
	if (ps->size) {
		return 0;
	}
	else {
		return -1;
	}
}

int SeqlistSize(PSeq ps) {
	assert(ps);
	return ps->size;
}

int SeqlistCapacity(PSeq ps) {
	assert(ps);
	return ps->capacity;
}

void SeqlistRemov(PSeq ps, DataType data) {
	assert(ps);
	SeqlistErase(ps,SeqlistFind(ps,data));
}

void SeqlistClear(PSeq ps) {
	assert(ps);
	ps->size = 0;
}

void SeqListDestroy(PSeq* ps) {
	assert(*ps);
	free((*ps)->arr);
	(*ps)->arr = NULL;
	(*ps)->capacity = 0;
	(*ps)->size = 0;
}

void CheckCapacity(PSeq ps) {
	assert(ps);
	ps->arr = (int*)realloc(ps->arr, (ps->capacity + SIZE)*sizeof(int));
	if (ps == NULL) {
		assert(0);
		return;
	}
	ps->capacity += SIZE;
}

int main() {
	Seqlist seqlist;
	PSeq ps = &seqlist;
	SeqlistInit(ps, SIZE);
	system("pause");
	return 0;
}