C语言单链表

// 准备头文件
#include <stdio.h>
#include <stdlib.h>

// 定义静态顺序表的最大长度和动态顺序表的初始默认最大容量
#define MaxSize 10      // 静态顺序表最大长度
#define InitSize 10     // 动态顺序表的初始默认长度

// 定义C语言的bool变量
#define bool char
#define true 1
#define false 0

/* 定义数据元素的数据类型 */
typedef int ElemType; // 方便更改

// 静态顺序表结构体定义
typedef struct Sqlist
{
    ElemType data[MaxSize];
	int length;
}Sqlist;
// 动态顺序表的结构体定义
typedef struct Sqlist_d
{
	ElemType *data;
	int length;
	int maxsize;
}Sqlist_d;


// 静态顺序表的输出
bool Sqlistprint(Sqlist L)
{
	// 判空
	if(L.length == 0)
	{
		printf("这个顺序表为空！\n");
		return false;
	}
	// 输出
	printf("Sqlist;");
	int i;
	for(i = 0; i < L.length; i++)
	{
		printf("%d-->", L.data[i]);
	}
	printf("end\n");

	return true;
}


// 动态顺序表的输出
bool Sqlist_dprint(Sqlist_d L)
{
	// 判空
	if(L.length == 0)
	{
		printf("这个顺序表为空！\n");
		return false;
	}
	// 输出
	printf("Sqlist_d;");
	int i;
	for(i = 0; i < L.length; i++)
	{
		printf("%d-->", L.data[i]);
	}
	printf("end\n");

	return true;
}

// 静态顺序表的初始化
bool InitSqList(Sqlist *L)
{
	L->length = 0;
	// 初始化元素？ 可以不用
	// int i;
	// for(i = 0;i < MaxSize; i++)
	// {
	// 	L->data[i] = 0;
	// }
}

// 动态顺序表的初始化
bool InitSqList_d(Sqlist_d *L)
{
	L->length = 0;
	L->maxsize = InitSize;
	// 为数据开辟空间
	L->data = (ElemType *)malloc(sizeof(ElemType) * InitSize);

	return true;
}

// 静态顺序表的插入
bool SqListInsert(Sqlist *L,int i,ElemType e)
{
	// 判断操作是否合法
	if(i < 1 || i > L->length + 1)
	{
		printf("插入位置不合法！\n");
		return false;
	}
	if(L->length >= MaxSize)
	{
		printf("这个表已经满了。\n");
		return false;
	}
	// 将第i位元素及其后面的元素向后移一位
	int j;  // length的长度刚好是当前最大下标加一
	for(j = L->length;j >= i;j--)
	{
		L->data[j] = L->data[j-1];
	}
	// 将新元素放到插入的位置
	L->data[i-1] = e;
	// 表长加1
	L->length++;
	// 插入成功返回true
	return true;
}

// 动态顺序表的插入
bool SqList_dInsert(Sqlist_d *L,int i,ElemType e)
{
	// 判断操作是否合法
	if(i < 1 || i > L->length + 1)
	{
		printf("插入位置不合法！\n");
		return false;
	}
	if(L->length >= L->maxsize)
	{
		printf("这个表已经满了。\n");
		return false;
	}
	// 将第i位元素及其后面的元素向后移一位
	int j; // length的长度刚好是当前最大下标加一
	for(j = L->length;j >= i;j--)
	{
		L->data[j] = L->data[j-1];
	}
	// 将新元素放到插入的位置
	L->data[i-1] = e;
	// 表长加1
	L->length++;
	// 插入成功返回true
	return true;
}

// 静态顺序表的元素删除
// 将顺序表中第i位元素删除并把它返回给e
bool SqListElemDelete(Sqlist *L, int i, ElemType *e)
{
	// 判断合法性
	if(i < 1 || i > L->length)
	{
		printf("删除位置不合法！\n");
		return false;
	}
	// 判空
	if(L->length == 0)
	{
		printf("这个表是空的！\n");
		return false;
	}
	// 将删除元素赋值给e
	*e = L->data[i-1];
	// 将第i位元素之后的元素向前移动一位
	int j; // 此时i若作为下标就是删除元素后一位的下标
	for(j = i; j < L->length; j++)
	{
		L->data[j-1] = L->data[j];
	}
	// 表长减一
	L->length--;
	return true;

}

// 动态顺序表的元素删除
bool SqList_dElemDelete(Sqlist_d *L, int i, ElemType *e)
{
	// 判断合法性
	if(i < 1 || i > L->length)
	{
		printf("删除位置不合法！\n");
		return false;
	}
	// 判空
	if(L->length == 0)
	{
		printf("这个表是空的！\n");
		return false;
	}
	// 将删除元素赋值给e
	*e = L->data[i-1];
	// 将第i位元素之后的元素向前移动一位
	int j; // 此时i若作为下标就是删除元素后一位的下标
	for(j = i; j < L->length; j++)
	{
		L->data[j-1] = L->data[j];
	}
	// 表长减一
	L->length--;
	return true;

}

// 静态顺序表的按值查找并返回其位序
int SqListLocElem(Sqlist L, ElemType e)
{
	int i;
	for(i = 0; i < L.length; i++)
	{
		if(L.data[i] == e)
		{
			return i + 1;
		}
	}
	return 0;
}
// 动态顺序表的按值查找并返回其位序
int SqList_dLocElem(Sqlist_d L, ElemType e)
{
	int i;
	for(i = 0; i < L.length; i++)
	{
		if(L.data[i] == e)
		{
			return i + 1;
		}
	}
	return 0;
}

// 动态顺序表的扩容
bool IncreaseSize(Sqlist_d *L, int len)
{
	// 生成一个新指针指向原来数据的空间
	ElemType *p = L->data;
	// 开辟更大的空间
	L->data = (ElemType *)malloc(sizeof(ElemType) * (L->length + len));
	// 转移数据
	int i;
	for(i = 0; i < L->length; i++)
	{
		L->data[i] = p[i]; // p[i] === *p + i
	}
	// 修改最大长度
	L->maxsize += len;
	// 释放原来的空间
	free(p);
	return true;
}



int main()
{
	// 生成顺序表
	Sqlist L1;
	Sqlist_d L2;

	// 初始化
	InitSqList(&L1);
	InitSqList_d(&L2);
	//插入一些元素
	SqListInsert(&L1,1,1);
	SqListInsert(&L1,2,2);
	SqListInsert(&L1,3,3);
	SqListInsert(&L1,4,4);
	SqListInsert(&L1,5,5);
	SqListInsert(&L1,6,6);
	SqListInsert(&L1,7,7);
	SqListInsert(&L1,8,8);
	SqListInsert(&L1,9,9);
	SqListInsert(&L1,10,10);

	SqList_dInsert(&L2,1,1);
	SqList_dInsert(&L2,2,2);
	SqList_dInsert(&L2,3,3);
	SqList_dInsert(&L2,4,4);
	SqList_dInsert(&L2,5,5);
	SqList_dInsert(&L2,6,6);
	SqList_dInsert(&L2,7,7);
	SqList_dInsert(&L2,8,8);
	SqList_dInsert(&L2,9,9);
	SqList_dInsert(&L2,10,10);
	SqList_dInsert(&L2,11,11);
	Sqlistprint(L1);
	Sqlist_dprint(L2);


	// 删除操作
	ElemType e1;
	ElemType e2;
	SqListElemDelete(&L1, 1, &e1);
	SqList_dElemDelete(&L2, 4, &e2);
	printf("e1 = %d\n", e1);
	printf("e2 = %d\n", e2);
	Sqlistprint(L1);
	Sqlist_dprint(L2);

	// 查询操作
	printf("L1的6是：第%d位\n",SqListLocElem(L1,6));
	printf("L2的4是：第%d位\n",SqList_dLocElem(L2,4));

	// 动态顺序表的扩容
	IncreaseSize(&L2, 20);
	Sqlist_dprint(L2);
	printf("L2的空间大小为：%d\n", L2.maxsize);

	return 0;
}