数据结构—顺序表

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

地址连续的空间，一般情况下采用数组，但数组有静态数组和动态数组

所以顺序表分为：静态顺序表和动态顺序表

程序分为三个部分：seqlist.h（头文件）、seqlist.c（函数实现）、 main.c（测试文件）

seqlist.h部分

#pragma once                                                   //防止头文件重复引用
#define MAX_SIZE 6                                             //用来设置结构体重数组的最大长度
#include<stdlib.h>
typedef char ListNode;

typedef struct SeqList
{
	ListNode arr[MAX_SIZE];
	size_t size;
}SeqList;

SeqList seqlist;
SeqList* s = &seqlist;                                           

void SeqListInit(SeqList* s);					//初始化
void SeqListInsertTail(SeqList *s, char c);			//尾部插入
void SeqListEraserTail(SeqList *s);				//尾部删除
void SeqListInsertHead(SeqList *s, char c);			//头部插入
void SeqListEraserHead(SeqList *s);				//头部删除
char SeqListAppointRead(SeqList *s, int position);		//指定位置读取数据 
void SeqListAppointReplace(SeqList *s, int position, char ch);	//修改指定位置元素
int SeqListAppointSeekSign(SeqList *s, char ch);		// 查找指定元素值的下标 找到返回下边，没找到返回-1
void SeqListRanmodInsert(SeqList *s, int position, char ch);	// 在任意位置插入元素

seqlist.c部分

将结构体中的数组的所有元素初始化为0，并且将size设置为0，在合理范围之内，每往数组中插入一个元素，size加1，每往删除一个元素，size减1。

在下面所有的函数中，传过来的指针可能是空指针，传过来的位置可能不合法，所以需要对这些参数进行判断

#include "seqlist.h"
void SeqListInit(SeqList* s)            //顺序表的初始化
{
	if(s == NULL)
	{
		//空指针
		return;
	}
	int i = 0;

	s->size = 0;
	for (i = 0; i < MAX_SIZE; i++)
	{
		s->arr[i] = 0;
	}
}

每次进行尾插的时候，只需要将需要插入的元素放到size所对应的下标处，传过来的数组可能是一个满数组，需要额外判断

void SeqListInsertTail(SeqList *s, char c)    //尾插
{
	if (s == NULL)
	{
		//空指针
		return;
	}
	if (s->size > (MAX_SIZE - 1))
	{
		//数组满
		return;
	}

	s->arr[s->size] = c;
	++s->size;
}

尾删只需要将size-1处的元素置0，然后将size减一，传过来的可能是空数组，要对这种情况做相应的处理

void SeqListEraserTail(SeqList *s)    //尾删
{
	if (s == NULL)
	{
		//空指针
		return;
	}
	if (s->size == 0)
	{
		//数组为空
		return;
	}

	s->arr[s->size - 1] = 0;
	--s->size;
}

头插：将已存在的元素向后移动一位，然后将要插入的元素放到0下标处，传过来的数组可能是一个满数组，需要额外判断

void SeqListInsertHead(SeqList *s, char c)    //头插
{
	if (s == NULL)
	{
		//空指针
		return;
	}
	if (s->size > (MAX_SIZE - 1))
	{
		//数组满
		return;
	}

	int i = s->size;
	while (i > 0)
	{
		s->arr[i] = s->arr[i - 1];
		i--;
	}
	s->arr[0] = c;
	++s->size;
}

头删：将一号下标及以后的所有元素往前移动一位，最后将最后一个元素置0，传过来的可能是空数组，要对这种情况做相应的处理

void SeqListEraserHead(SeqList *s)    //头删
{
	if (s == NULL)
	{
		//空指针
		return;
	}
	if (s->size == 0)
	{
		//空数组
		return;
	}

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

返回传进来的位置对应坐标的上一个元素，例：position = 3,  返回的值为s->arr[2]

char SeqListAppointRead(SeqList *s, int position)  //读取指定位置的元素
{
	if(s == NULL)
	{
		//空指针
		return;
	}
	if (position < 0 || position > MAX_SIZE)
	{
		//位置错误
		return;
	}
	return s->arr[position - 1];
}

将 arr[position - 1]  的值替换为 ch

void SeqListAppointReplace(SeqList *s, int position, char ch)     //替换指定位置的元素
{
	if (s == NULL)
	{
		//空指针
		return;
	}
	if (position < 0 || position > MAX_SIZE)
	{
		//位置错误
		return;
	}

	s->arr[position - 1] = ch;
}

从arr下标在0~size-1之间查找 ch ，如果找到，则返回对应的下标，如果没找到，返回-1int SeqListAppointSeekSign(SeqList *s, char ch) //查找指定元素的下标  

{
	if (s == NULL)
	{
		//空指针
		return;
	}

	int i = 0;
	for (; i < s->size; i++)
	{
		if (s->arr[i] == ch)
		{
			break;
		}
	}

	if (i >= s->size)
	{
		//未找到返回 -1
		return -1;
	}
	else
	{
		//找到返回下标
		return  i;
	}
}

将position位置及以后的元素向后移动一位，并将ch插入arr[position-1]处，传过来的数组可能是一个满数组，需要额外判断

void SeqListRanmodInsert(SeqList *s, int position, char ch)   //在任意位置插入新元素
{
	if (s == NULL)
	{
		//空指针
		return;
	}
	if (position < 0 || position >MAX_SIZE)
	{
		//位置错误
		return;
	}
	if (s->size == 6)
	{
		//数组满
		return;
	}

	int i = s->size;
	for (; i>=position ;i--)
	{
		s->arr[i] = s->arr[i-1];
	}
	++s->size;
	s->arr[position - 1] = ch;
}

main.c部分

#include "seqlist.h"
#define PRINTNAME printf("\n===================%s================\n", __FUNCTION__)    //打印所在函数的函数名

SeqList seqlist;
SeqList* s = &seqlist;

void print(SeqList *s)
{
	int i = 0;
	for (i = 0; i < MAX_SIZE; i++)
	{
		printf("%c", s->arr[i]);
	}
	printf("\n");
}

void testInit()
{
	PRINTNAME;
	SeqListInit(s);
	printf("期望值为0，实际值是:%d\n", s->size);
	print(s);
}

void testInsertTail()
{
	PRINTNAME;
	SeqListInsertTail(s, '1');
	SeqListInsertTail(s, '2');
	SeqListInsertTail(s, '3');
	SeqListInsertTail(s, '4');
	SeqListInsertTail(s, '5');
	SeqListInsertTail(s, '6');
	SeqListInsertTail(s, '7');
	SeqListInsertTail(s, '8');
	print(s);
}

void testEraserTail()
{
	PRINTNAME;
	SeqListEraserTail(s);
	SeqListEraserTail(s);
	SeqListEraserTail(s);
	print(s);
}


void testInsertHead()
{
	PRINTNAME;
	SeqListInsertHead(s, 'a');
	SeqListInsertHead(s, 'b');
	SeqListInsertHead(s, 'c');
	SeqListInsertHead(s, 'd');
	SeqListInsertHead(s, 'e');
	print(s);
}

void testEraserHead()
{
	PRINTNAME;
	SeqListEraserHead(s);
	SeqListEraserHead(s);
	print(s);
}

void testAppointRead()
{
	PRINTNAME;
	printf("%c\n", SeqListAppointRead(s, 3));
}


void testAppointReplace()
{
	PRINTNAME;
	SeqListAppointReplace(s, 4, '#');
	SeqListAppointReplace(s, 1, '*');
	print(s);
}

void testAppointSeekSign()
{
	PRINTNAME;
	printf("%d ", SeqListAppointSeekSign(s, '#'));
	printf("%d ", SeqListAppointSeekSign(s, '*'));
	printf("%d ", SeqListAppointSeekSign(s, '('));
	printf("\n");
}

void testRanmodInsert()
{
	PRINTNAME;
	SeqListRanmodInsert(s, 3, 'A');
	SeqListRanmodInsert(s, 3, 'B');
	SeqListRanmodInsert(s, 3, 'A');
	SeqListRanmodInsert(s, 3, 'D');
	print(s);
}

int main()
{
	testInit();
	testInsertTail();
	testEraserTail();
	testInsertHead();
	testEraserHead();
	testAppointRead();
	testAppointReplace();
	testAppointSeekSign();
	testRanmodInsert();

	system("pause");
	return 0;
}

运行结果：