C语言实现顺序表（考研笔记）

概述

给需要考研的同学一个参考，顺序表作为常见数据结构的一种，这里记录一期关于C语言实现顺序表。

代码实现

函数定义、结构体、常量、宏定义

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#define MAX_SIZE 10
#define true 1
#define false 0
#define bool char
typedef int ElementType ;
typedef struct SeqList {
	ElementType* data;
	int maxLen;
	int len;
} SeqList;
SeqList* intSeqList(SeqList* L);
void increaseSize(SeqList *L, int increaseLen);
bool insert(SeqList* L,int pos, int element);
bool del(SeqList* L, int pos);
bool update(SeqList* L, int pos, ElementType elemnt);
ElementType getElement(SeqList* L, int pos);

main函数

jint main() {
	SeqList L;
	intSeqList(&L);
	for (int i = 0; i < L.maxLen; i++) {
		insert(&L, i, i);
	}
	increaseSize(&L, 10);
	insert(&L, 15, 126);
	update(&L, 7, 77);
	del(&L, 15);
	for (int i = 0; i < L.maxLen; i++) {
		printf("L->data[%d]=%d\n", i, L.data[i]);
	}
	printf("长度为%d\n", L.len);
	printf("L->data[%d]\n", getElement(&L, 7));
	return 0;
}

顺序表初始化

SeqList* intSeqList(SeqList* L) {
	assert(L);
 	ElementType* newL = (ElementType*)malloc(MAX_SIZE * sizeof(ElementType));
	if (newL) {
		L->data = newL;
		for (int i = 0; i < MAX_SIZE; i++) {
			L->data[i] = 0;
		}
		L->len = 0;
		L->maxLen = MAX_SIZE;
	}
	return L;
}

动态扩容顺序表

void increaseSize(SeqList* L, int increaseLen) {
	ElementType* p = L->data;
	ElementType* newL = (ElementType*)realloc(L->data, (L->maxLen + increaseLen) * sizeof(ElementType));
	if (newL) {
		L->data = newL;
		for (int i = L->maxLen; i < L->maxLen+increaseLen; i++) {
			L->data[i] = 0;
		}
		L->maxLen = L->maxLen + increaseLen;
	}
}

顺序表插入元素

bool insert(SeqList* L,int pos, ElementType elemnt) {
	if (pos < 0 || pos >= L->maxLen) {
		return false;
	}
	ElementType* p = L->data;
	//pos位置以后的元素后移
	int start = 0;
	while (start < L->maxLen) {
		if (start == pos) {
			break;
		}
		p++;
		start++;
	}
	for (int i = L->maxLen - 1; i > start; i--) {
		L->data[i] = L->data[i - 1];
	}
	*p = elemnt;
	L->len = L->len + 1 > L->maxLen ? L->maxLen : ++L->len;
	return true;
}

表删除元素(通过位置删除)

bool del(SeqList* L, int pos) {
	if (pos < 0 || pos >= L->maxLen) {
		return false;
	}
	ElementType* p = L->data;
	//pos位置以后的元素后移
	int start = 0;
	while (start < L->maxLen) {
		if (start == pos) {
			break;
		}
		p++;
		start++;
	}
	for (int i = start; i < L->maxLen; i++) {
		if (i == L->maxLen-1) {
			L->data[i] = 0;
		}
		else {
			L->data[i] = L->data[i + 1];
		}
	}
	L->len--;
	return true;
}

顺序表修改元素(通过位置修改)

bool update(SeqList* L, int pos, ElementType elemnt) {
	if (pos < 0 || pos >= L->maxLen) {
		return false;
	}
	L->data[pos] = elemnt;
	return true;
}

顺序表查找元素(通过位置查找)

ElementType getElement(SeqList* L, int pos) {
	if (pos < 0 || pos >= L->maxLen) {
		return false;
	}
	return L->data[pos];
}

总结

上面代码按照我个人习惯书写，更多的临界值判断可以自行添加。