数据结构（c语言实现）--顺序表的基本操作，包括初始化、插入、删除、遍历等操作

顺序表的基本操作

顺序表的结构

typedef struct node {
	int *elem;//定义数组的基地址
	int len;//定义数组的现有长度
	int listSize;//允许储存的最大数量
}Node;

顺序表的初始化

bool InitList(Node *l) {
	l->elem = (int *)malloc(sizeof(int));//对数组的基地址进行初始化
	if (!l->elem)
	{
		return false;
	}
	l->listSize = maxLen;
	l->len = 0;//初始化数组的长度为0
	return true;
}

获取顺序表的长度

如果数组的基地址不为空，就返回数组的长度
int LengthList(Node *l) {
	if (l->elem==NULL)
	{
		return -1;
	}
	return l->len;
}

顺序表的插入（在指定位置插入）

bool InsertData(Node *l, int i, int data) {
	if (i<1||l->len>LengthList(l))
	{
		
		return false;//判断数组是否为空
	}
	if (l->len>=l->listSize)
	{
		l->elem = (int*)realloc(l->elem, (l->listSize + 1000) * sizeof(int));
		if (!l->elem) return false;//如果数组超出listSize，就动态的分配加入
		l->listSize += 1000;		
	}
	for (int k = i; k <=l->len; k++)
	{
		l->elem[k + 1] = l->elem[k];
	}//然后从第i个位置开始，元素依次往后移
	l->elem[i - 1] = data;
	l->len++;//最后别忘了将对应的数组的长度+1
	return true;
}

顺序表的插入（头部插入）

bool InsertOfHead(Node *l, int data) {
	if (l->len >= l->listSize)
	{//在头部插入时首先判断数组是不是满的，满了就动态加入
		l->elem = (int*)realloc(l->elem, (l->listSize + 1000) * sizeof(int));
		if (!l->elem) return false;
		l->listSize += 1000;
	}
	for (int i = l->len; i>0 ; i--)
	{
		l->elem[i] = l->elem[i - 1];//从最后一个元素开始，数组中的元素依次后移
	}
	l->elem[0] = data;
	l->len++;//最后依然要将len+1
	return true;
}

顺序表的插入（尾部插入）

bool InsertOfTail(Node *l, int data) {
	if (l->len >= l->listSize)
	{//在尾部插入时首先判断数组是不是满的，满了就动态加入
		l->elem = (int*)realloc(l->elem, (l->listSize + 1000) * sizeof(int));
		if (!l->elem) return false;
		l->listSize += 1000;
	}
	l->elem[l->len] = data;//直接在尾部将数据加入
	l->len++;//最后依然要将len+1
	return true;
}

顺序表的删除（删除指定位置的元素）

bool DeleteByIndex(Node *l, int i) {
	if (i<1 || l->len>LengthList(l))
	{
		return false;//判断数组是否为空
	}
	for (int k = i; k < l->len; k++)
	{
		l->elem[k - 1] = l->elem[k];//将数组中的元素依次向前移
	}
	l->len--;//最后别忘了将len-1
	return true;
}

删除头部元素

bool DeleteHead(Node *l) {
	if (Empty(l)!=true){
		return false;//在删除时首先判断数组是否为空
	}
	for (int i = 1; i <=l->len; i++)
	{
		l->elem[i - 1] = l->elem[i];//将顺序表的元素从1开始依次迁移
	}
	l->len--;//将len-1
	return true;
}

删除尾部元素

bool DeleteTail(Node *l) {
	if (Empty(l)!=true) {
		return false;//在删除时首先判断数组是否为空
	}
	l->len--;//直接将len-1，即删除了尾元素
	return true;
}

按值查找元素，返回元素的下标

int SearchByData(Node *l, int data) {
	for (int i = 0; i < l->len; i++)
	{
		if (l->elem[i] == data)
			return i + 1;//依次遍历数组，如果与待查找的数值相等，就返回它的位置
	}
	return -1;//没有找到就返回-1
}

通过下标查找元素，返回元素的值

int SearchByIndex(Node *l, int i) {
	if (i<1||i>l->len)
	{
		return -1;//判断传进来的下标是否合法
	}
	return l->elem[i - 1];
}

清空顺序表

void ClearList(Node *l) {
	l->len = 0;//将len置为0，将数组清空
}

判断顺序表是否为空

bool Empty(Node *l) {
	if (l->len==0)
	{
		return false;
	}
	return true;//通过len的大小判断数组是否为空
}

顺序表的遍历

void printList(Node *l) {
	for (int i = 0; i < l->len; i++)
	{
		printf("%d ", l->elem[i]);
	}
	printf("\n");
}

完整代码

#include<stdlib.h>
#include<stdio.h>
#include<stdlib.h>
# define maxLen 1000
typedef struct node {
	int *elem;//定义数组的基地址
	int len;//定义数组的现有长度
	int listSize;//允许储存的最大数量
}Node;
bool InitList(Node *l);//初始化数组
int LengthList(Node *l);//获取数组的长度
bool InsertData(Node *l, int i, int data);//向指定位置插入数据
bool DeleteByIndex(Node *l, int i);//删除指定下标的数据
int SearchByData(Node *l, int data);//获取数据的下标
int SearchByIndex(Node *l, int i);//获取指定下标的数据
void ClearList(Node *l);//清空顺序表
bool Empty(Node *l);//判断顺序表是否为空
void printList(Node *l);//遍历顺序表
bool InsertOfHead(Node *l, int data);//在顺序表的头部插入数据
bool InsertOfTail(Node *l, int data);//在顺序表的尾部插入数据
bool DeleteHead(Node *l);//删除头部元素
bool DeleteTail(Node *l);//删除尾部元素
int main() {

	int choice;
	Node *l = (Node *)malloc(sizeof(Node));
	int i;
	int data;
	int index;
	while (true)
	{
		printf("\n=====顺序表的操作=====\n");
		printf("1.顺序表的初始化\n");
		printf("2.求顺序表的长度\n");
		printf("3.顺序表的指定位置插入\n");
		printf("11.在头部插入元素\n");
		printf("12.在尾部插入元素\n");
		printf("4.删除指定位置的元素\n");
		printf("13.删除头部元素\n");
		printf("14.删除尾部元素\n");
		printf("5.查找某个元素在表中的位置\n");
		printf("6.获取某个位置元素的值\n");
		printf("7.清空顺序表\n");
		printf("8.判断顺序表是否为空\n");
		printf("9.遍历顺序表\n");
		printf("10.退出程序。。。。。。。。\n");
		printf("\n请输入你的选择：");
		scanf("%d", &choice);
		switch (choice)
		{
		case 1:
			
			if (InitList(l))
			{
				printf("\n初始化成功！\n");
			}
			break;
		case 2:
			if (LengthList(l)!=-1)
			{
				printf("\n顺序表的长度为：%d\n", LengthList(l));
			}
			break;
		case 3:
			printf("请输入要插入的位置：");
			scanf("%d", &i);
			printf("请输入要插入的数据：");
			scanf("%d", &data);
			if (InsertData(l,i,data))
			{
				printf("\n插入成功！\n");
			}
			else {
				printf("插入位置不合法！\n");
			}
			break;
		case 4:
			printf("请输入要删除的元素的下标：");
			scanf("%d", &i);
			if (DeleteByIndex(l,i))
			{
				printf("\n删除成功!\n");
			}
			else {
				printf("\n下标不合法！\n");
			}
			break; 
			case 5:
				printf("请输入需要查找的数据：");
				scanf("%d", &data);
				index = SearchByData(l, data);
				if (index==-1)
				{
					printf("\n没有找到数据！\n");
				}
				else {
					printf("\n%d在顺序表中的数据为：%d\n", data, index);
				}
				break;
			case 6:
				printf("\n请输入获取的元素的下标：");
				scanf("%d", &i);
				data = SearchByIndex(l, i);
				if (data==-1)
				{
					printf("\n下标不合法！\n");
				}
				else {
					printf("\n在%d位置的数据为：%d", i, data);
				}
				break;
			case 7:
				ClearList(l);
				break;
			case 8:
				if (Empty(l))
				{
					printf("\n顺序表不为空！\n");
				}
				else {
					printf("\n顺序表为空！\n");
				}
				break;
			case 9:
				printList(l);
				break;
			case 10:
				exit(0);
				break;
			case 11:
				printf("请输入要插入的数据：");
				scanf("%d", &data);
				if (InsertOfHead(l, data))
				{
					printf("\n插入成功！\n");
				}
				else {
					printf("\n插入失败！\n");
				}
				break;
			case 12:
				printf("请输入要插入的数据：");
				scanf("%d", &data);
				if (InsertOfTail(l, data))
				{
					printf("\n插入成功！\n");
				}
				else {
					printf("\n插入失败！\n");
				}
				break;
			case 13:
				if (DeleteHead(l))
				{
					printf("\n删除成功！\n");
				}
				else {
					printf("\n删除失败!\n");
				}
				break;
			case 14:
				if (DeleteTail(l))
				{
					printf("\n删除成功！\n");
				}
				else {
					printf("\n删除失败!\n");
				}
				break;

		}
	}
	printf("\n退出程序。。。。。。。。。。\n");
}
bool InitList(Node *l) {
	
	l->elem = (int *)malloc(sizeof(int));//对数组的基地址进行初始化
	if (!l->elem)
	{
		return false;
	}
	l->listSize = maxLen;
	l->len = 0;//初始化数组的长度为0
	return true;
}
/*

如果数组的基地址不为空，就返回数组的长度
*/
int LengthList(Node *l) {
	if (l->elem==NULL)
	{
		return -1;
	}
	return l->len;
}
bool InsertData(Node *l, int i, int data) {
	if (i<1||l->len>LengthList(l))
	{
		
		return false;//判断数组是否为空
	}
	if (l->len>=l->listSize)
	{
		l->elem = (int*)realloc(l->elem, (l->listSize + 1000) * sizeof(int));
		if (!l->elem) return false;//如果数组超出listSize，就动态的分配加入
		l->listSize += 1000;		
	}
	for (int k = l->len; k >=i;k--)
	{
		
		l->elem[k] = l->elem[k-1];
	}//然后从第i个位置开始，元素依次往后移
	l->elem[i - 1] = data;
	l->len++;//最后别忘了将对应的数组的长度+1
	return true;
}
bool DeleteByIndex(Node *l, int i) {
	if (i<1 || l->len>LengthList(l))
	{

		return false;//判断数组是否为空
	}
	for (int k = i; k < l->len; k++)
	{
		l->elem[k - 1] = l->elem[k];//将数组中的元素依次向前移
	}
	l->len--;//最后别忘了将len-1
	return true;
}
int SearchByData(Node *l, int data) {
	for (int i = 0; i < l->len; i++)
	{
		if (l->elem[i] == data)
			return i + 1;//依次遍历数组，如果与待查找的数值相等，就返回它的位置
	}
	return -1;//没有找到就返回-1
}
int SearchByIndex(Node *l, int i) {
	if (i<1||i>l->len)
	{
		return -1;//判断传进来的下标是否合法
	}
	return l->elem[i - 1];
}
void ClearList(Node *l) {
	l->len = 0;//将len置为0，将数组清空

}
bool Empty(Node *l) {
	if (l->len==0)
	{
		return false;
	}
	return true;//通过len的大小判断数组是否为空
}
void printList(Node *l) {
	for (int i = 0; i < l->len; i++)
	{
		printf("%d ", l->elem[i]);
	}
	printf("\n");
}
bool InsertOfHead(Node *l, int data) {
	if (l->len >= l->listSize)
	{//在头部插入时首先判断数组是不是满的，满了就动态加入
		l->elem = (int*)realloc(l->elem, (l->listSize + 1000) * sizeof(int));
		if (!l->elem) return false;
		l->listSize += 1000;
	}
	for (int i = l->len; i>0 ; i--)
	{
		l->elem[i] = l->elem[i - 1];//从最后一个元素开始，数组中的元素依次后移
	}
	l->elem[0] = data;
	l->len++;//最后依然要将len+1
	return true;
}
bool InsertOfTail(Node *l, int data) {
	if (l->len >= l->listSize)
	{//在尾部插入时首先判断数组是不是满的，满了就动态加入
		l->elem = (int*)realloc(l->elem, (l->listSize + 1000) * sizeof(int));
		if (!l->elem) return false;
		l->listSize += 1000;
	}
	l->elem[l->len] = data;//直接在尾部将数据加入
	l->len++;//最后依然要将len+1
	return true;
}
bool DeleteHead(Node *l) {
	if (Empty(l)!=true){
		return false;//在删除时首先判断数组是否为空
	}
	for (int i = 1; i <=l->len; i++)
	{
		l->elem[i - 1] = l->elem[i];//将顺序表的元素从1开始依次迁移
	}
	l->len--;//将len-1
	return true;
}
bool DeleteTail(Node *l) {
	if (Empty(l)!=true) {
		return false;//在删除时首先判断数组是否为空
	}
	l->len--;//直接将len-1，即删除了尾元素
	return true;
}