数据结构----基本顺序表的操作

顺序表一共分为两类：静态表、动态表。
动态表代码：

# include <stdio.h>
# include <malloc.h>
# include <stdlib.h>
struct SqList
{
	int * pArr; //储存的是数组的第一个元素的地址
	int len;   //数组所能容纳的最大元素的个数
	int cent; //当前数组有效元素的个数
};

void Display_Arr(SqList *L);
bool append_Arr(SqList * L, int val);
bool is_full(SqList * L);
void InitList(SqList * L,int length);
bool delate_Arr(SqList * L,int index);
bool Insert_Arr(SqList * L,int index,int val);
void sort_Arr(SqList * L);


int main()
{
	SqList sq;
	InitList(&sq,10);
	append_Arr(&sq,1);
	append_Arr(&sq,2);
	append_Arr(&sq,3);
	Display_Arr(&sq);
	Insert_Arr(&sq,1,10);
	Display_Arr(&sq);
	Insert_Arr(&sq,2,11);
	Insert_Arr(&sq,5,12);
	Display_Arr(&sq);
	Insert_Arr(&sq,8,13);
	Display_Arr(&sq);
	delate_Arr(&sq,5);
	Display_Arr(&sq);
	delate_Arr(&sq,8);
	Display_Arr(&sq);
	delate_Arr(&sq,1);
	Display_Arr(&sq);
	sort_Arr(&sq);
	Display_Arr(&sq);
	return 0;
}

/*
	创建一个动态分配内存的数组  
	结构体中的pArr指向生成的整型地址内存的的首地址，生成的数组类型为整型int(强制类型转换为int *，为整型的地址)
	L-Arr保存了数组的首地址
	两个参数：
		L  Length ， L为结构体指针变量，Length为生成的最大数组长度
*/
void InitList(SqList * L,int length)
{
	L->pArr = (int *)malloc(sizeof(int)*length);  //创建一个长度为length的整型(int)数组 pArr指向创建数组的首地址
	if(NULL == L->pArr)
	{
		printf("动态内存分配失败!\n");
		exit(-1);
	}
	else
	{
		L->len = length;//最大长度已确定，为Length
		L->cent = 0;//表明还没有数据存储在生成的数组中，没有将数据放到生成的那一块内存空间中
	}
}

/*
	判断数组是否完全被数据填充
	即有效元素的个数与生成的数组最大个数相等
	参数一个：
		L为结构体SqList的指针变量
*/
bool is_full(SqList * L)
{
	if(L->cent == L->len)
		return true;
	else
		return false;
}
/*
	追加元素，在数组的尾部进行元素的追加
	参数：val为追加数据的内容
*/
bool append_Arr(SqList * L, int val)
{
	if(is_full(L))
	{
		printf("数组已满\n");
		return false;
	}
	else  //L->pArr[i],即为数组中的第i个元素，L->pArr指向数组的首地址,L->pArr[i]即为数组的第i个元素
	{
		L->pArr[L->cent] = val;
		(L->cent)++;
		return true;
	}
}
/*
	显示数组，对数组进行输出
*/
void Display_Arr(SqList *L) 
{
	int i;
	for (i = 0; i < L->cent; i++) 
	{
		printf("%d->",L->pArr[i]);
	}
	printf("NUll\n");
}

/*
	判断数组是否是空的
*/
bool is_empty(SqList * L)
{
	if(L->cent == 0)
		return true;
	else
		return false;
}

/*
	在相应位置插入相应的数据
*/

bool Insert_Arr(SqList * L,int index,int val)
{
	if(is_full(L))
	{
		printf("数组元素已满,不能进行数据插入\n");
		return false;
	}
	if(index<1||index>L->cent)
	{
		printf("插入数据失败，请在正确位置插入，1<index<%d\n",L->cent);
		return false;
	}
	if(index != L->cent)
	{
		int i;
		for(i=L->cent;i>index;i--)
		{
			L->pArr[i] = L->pArr[i-1];
		}
		L->pArr[index] = val;
		L->cent++;
	}
	else
	{
		append_Arr(L,val);
	}
	return true;
}

bool delate_Arr(SqList * L,int index)
{
	if(is_empty(L))
	{
		printf("数组为空，不能删除\n");
		return false;
	}
	else
	{
		if(index<0||index>L->cent)
		{
			printf("index不是有效范围,应该输入index范围为0~%d\n",L->cent);
			return false;
		}
		else
		{
			int i;
			for(i=index;i<L->cent;i++)
			{
				L->pArr[i] = L->pArr[i+1];
			}
			L->cent--;
			return true;
		}
	}
}
/*
	排序  冒泡排序法进行排序
*/
void sort_Arr(SqList * L)
{
	int i, j, t;

	for (i=0; i<L->cent; ++i)
	{
		for (j=i+1; j<L->cent; ++j)
		{
			if (L->pArr[i] > L->pArr[j])
			{
				t = L->pArr[i];
				L->pArr[i] = L->pArr[j];
				L->pArr[j] = t;
			}
		}
	}
}

静态表代码：

/*
	静态顺序表  使用定长的数组进行存储
	静态顺序表只适用于确定知道需要存多少数据的场景。
	静态顺序表的定长数组导致N定大了，空间开多 了浪费，开少了不够用。
	所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小
	该程序未使用malloc函数动态生成内存

*/

#include<stdio.h>
#define MAX 20 //最大元素个数

// 用于保存顺序线性表的结构体  定义了一个线性表  前面为数组数据静态分配(最大为20个数据) 后面为数据个数
//从头到尾只有这一个结构体
//定义一个结构体类型
typedef struct {
	int data[MAX];
	int count; //当前元素个数
}SqList;

// 获取元素个数 返回值为元素的个数
int getCount(SqList *list)
{
	return list->count;  //(*list).count
}

// 显示所有元素
void DisplayList(SqList *list) 
{
	int i;
	printf("\n所有元素:");
	for (i = 0; i < list->count; i++) 
	{
		printf("%d-->",list->data[i]);
	}
	printf("NUll\n");
}

// 获取指定位置元素，返回值放入result指向元素 index 为取的指定的位置 result为指定位置的值
bool getData(SqList *list,int index,int *result)
{
	if (index<0 || index>list->count-1) 
	{
		return false;//false表示失败
	}
	*result = list->data[index];
	return true;//ture表示成功
}

// 插入元素  list为插入的链表的地址 index插入为位置 input为插入的数据 有返回值  false为失败 true为成功
bool insertData(SqList *list,int index, int input)
{
	int i;
	if (list->count >= MAX) //数组全部成员都被占据  数组已经满了
	{
		return false;
	}

	if (index<0 || index>list->count) //不在合理范围
	{
		return false;
	}

	if (index != list->count) //插入数据不在表尾
	{
		for (i = list->count;i>=index;i--) //依次后移，给插入的数据空出位置
		{
			list->data[i] = list->data[i - 1];
		}
	}

	//依次后移后，将数据插入相应的位置
	//或者直接插入相应的尾部，不用进行数据的移动
	list->data[index] = input;
	list->count++; //元素个数增加的有效
	return true;
}

// 删除指定位置元素
bool deleteData(SqList *list, int index) 
{
	int i;
	if (index<0 || index>list->count - 1) //不在合理范围
	{
		return false;//表示删除元素失败
	}
	for (i = index; i < list->count - 1; i++) 
	{
		list->data[i] = list->data[i +1];
	}
	list->count--;
	return true;//表示删除元素成功
}
// 清空所有元素
void clearData(SqList *list) 
{
	list->count = 0;

}


// 所有程序的入口main函数
int main()
{
	//初始化
	SqList sqlList; //sqList 的类型为SqList等价于struct  定义了一个结构体变量 
	SqList *list=&sqlList;  //定义一个list的头指针指向sqList  list保存了sqList的地址
	list->count = 0;//现在的有效元素的个数为0

	//插入元素
	insertData(list, 0, 1);
	insertData(list, 1, 2);
	insertData(list, 2, 3);
	insertData(list, 3, 3);
	insertData(list, 4, 3);
	DisplayList(list);

	//获取元素
	int result;
	getData(list, 1, &result);
	printf("getData:%d\n",result);

	
	//删除指定位置元素
	deleteData(list,1);
	DisplayList(list);

	//清空元素
	clearData(list);
	DisplayList(list);
	printf("\n");
	return 0;
	
}