单链表——顺序存储

#include <stdafx.h>
#include <stdio.h>
#include <stdlib.h>
#include <io.h>
#include <math.h>
#include <time.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 20 //存储空间初始分配量


typedef int Status; //Status是函数的类型，其值是函数结果状态代码，如OK等
typedef int ElemType; //ElemType类型根据实际情况而定，这里假设为int

Status visit(ElemType c)
{
	printf("%d", c);
	return OK;
}

//结构体作用：把20个数组元素和一个int型数据元素封装成一个结构体类型，并命名为SqList
typedef struct
{
	ElemType data[MAXSIZE]; //数组，存储数据元素
	int length; //线性表当前长度
}SqList;

//初始化顺序线性表
Status InitList(SqList *L)
{
	L->length = 0;
	return OK;
}

//是否为空
Status ListEmpty(SqList L)
{
	if (L.length == 0)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

//清空线性表
Status ClearList(SqList *L)
{
	L->length = 0;
	return  OK;
}

//返回线性表元素个数
int ListLength(SqList L)
{
	return L.length;
}

//获取i个元素的值
Status GetElem(SqList L, int i, ElemType *e)
{
	if (L.length == 0 || i<1 || i>L.length)
	{
		return ERROR;
	}
	*e = L.data[i - 1];

	return OK;
}

//查找,返回查找值的位置
int LocateElem(SqList L, ElemType e)
{
	int i;
	if (L.length == 0)
	{
		return 0;
	}
	for (i = 0; i < L.length; i++)
	{
		if (L.data[i] == e)
		{
			break;
		}
	}
	if (i >= L.length)
	{
		return 0;
	}
	return i + 1;

}

//插入，在第i个位置之前插入
Status ListInsert(SqList *L, int i, ElemType e)
{
	int k;
	if (L->length == MAXSIZE) //表满
	{
		return ERROR;
	}
	if (i<1 || i>L->length + 1) //当比第一个元素位置小或者比最后一个元素位置大时
	{
		return ERROR;
	}

	if (i <= L->length) //若插入数据不在表尾
	{
		for (k = L->length - 1; k >= i - 1; k--) //将要插入位置后的数据元素依次向后移动一位
		{
			L->data[k + 1] = L->data[k]; //将第i个元素的值赋给第i+1个元素
		}
	}
	L->data[i - 1] = e; //插入新元素
	L->length++; //表长加1

	return OK;
}

//删除第i个元素，并返回其值
Status ListDelete(SqList *L, int i, ElemType *e)
{
	int k;
	if (L->length == 0) //线性表为空
	{
		return ERROR;
	}
	if (i<1 || i>L->length) //删除位置不正确
	{
		return ERROR;
	}
	*e = L->data[i - 1];
	if (i < L->length) //如果删除元素不是最后一个
	{
		for (k = i; k < L->length; k++) //将删除位置后继元素前移
		{
			L->data[k - 1] = L->data[k]; //将第i+1个元素的值赋给第i个元素
		}
	}
	L->length--; //表长减1
	return OK;
}

//遍历输出表元素
Status ListTraverse(SqList L)
{
	int i;
	for (i = 0; i < L.length; i++)
	{
		visit(L.data[i]);
	}
	printf("\n");
	return OK;
}

//联合A,B,把属于表B但不属于表A的数据元素插入表A（求AB的并集）
void unionL(SqList *La, SqList Lb)
{
	int La_len, Lb_len, i;
	ElemType e;
	La_len = ListLength(*La);
	Lb_len = ListLength(Lb);
	for (i = 1; i < Lb_len; i++)
	{
		GetElem(Lb, i, &e);
		int s = LocateElem(*La, e);
		if (!LocateElem(*La, e))
		{
			ListInsert(La, ++La_len, e);
		}
	}
}

int main()
{
	SqList L; //定义一个SqList结构体变量，生成一个顺序表
	SqList Lb;

	ElemType e; 
	Status i;
	int j, k;
	i = InitList(&L); //初始化顺序表，只是把表长置零
	printf("初始化L后：L.length=%d\n", L.length);

	//从第一个位置一次插入5个元素
	for (j = 1; j <= 5; j++)
	{
		i = ListInsert(&L, 1, j);
	}
	printf("在L的表头依次插入1-5后：L.data=");
	ListTraverse(L);

	//判断现在表是否为空
	printf("L.length=%d \n", L.length);
	i = ListEmpty(L);
	printf("L是否为空：i=%d(1:是 0：否)\n", i);
	
	/**********************************/
	//&L与L的区别：
	//&L是一个指向L的地址，是*SqList类型
	//L是顺序表，是一个包括一个数组和一个整型数据的结构体，是SqList类型
	//当主调函数调用被调函数时，实参向形参传递&L传递的只是一个地址（指针）
	//传递L是传递的是一个结构体类型数据
	//当传递指针(&L)时，可以改变顺序表（增、删、改），节省内存空间
	//当传递顺序表(L)是，只能访问顺序表，不可以做任何改变，浪费内存空间
	//&L是顺序表的地址，而L是顺序表
	/***********************************/

	//清空表，并判断是否为空
	i = ClearList(&L);
	printf("清空L后：L.length=%d\n", L.length);
	printf("&L的值:%d\n", &L);
	i = ListEmpty(L);
	printf("L是否为空：i=%d(1:是 0:否)\n", i);
	printf("L的值：%d\n", L);

	//插入1~10
	for (j = 1; j <= 10; j++)
	{
		ListInsert(&L, j, j);
	}
	printf("在L的表尾依次插入1-10后：L.data=");
	ListTraverse(L);

	printf("L.length=%d \n", L.length);

	ListInsert(&L, 1, 0);
	printf("在L的表头插入0后：L.data=");
	ListTraverse(L);
	printf("L.length=%d \n", L.length);

	GetElem(L, 5, &e);
	printf("第5个元素的值为：%d \n", e);

	//输出3,4的位置
	for (j = 3; j <= 4;j++)
	{
		k = LocateElem(L, j);
		if (k)
			printf("第%d个元素的值为%d\n", k, j);
		else
		{
			printf("没有值为%d的元素\n", j);
		}
	}

	//删除数据
	k = ListLength(L); //k为表长
	for (j = k + 1; j >= k; j--)
	{
		i = ListDelete(&L, j, &e); //删除第j个数据
		if (i == ERROR)
			printf("删除第%d个数据失败\n", j);
		else
		{
			printf("删除第%d个元素值为：%d\n", j, e);
		}
	}
	printf("依次输出L的元素：");
	ListTraverse(L);

	//构造一个有10个数的Lb
	i = InitList(&Lb);
	for (j = 6; j <= 15; j++)
	{
		i = ListInsert(&Lb, 1, j);
	}

	//合并L,Lb
	unionL(&L, Lb);
	//数据合并后的L
	ListTraverse(L);

	system("pause");

	return 0;
}