数据结构----线性表的顺序实现

/*
***************************线性表的顺序实现:用一组地址连续的存储单元依次存储线性表的数据元素
*************************即用数组的实现
参考自：http://blog.csdn.net/thefutureisour/article/details/7830062
*/
#include <stdio.h>
#include <malloc.h>

typedef int ElemType;

typedef struct ArrayList
{
    ElemType *aArray;//实际的数组
    int iLength;//实际的元素个数
    int iSize;//容量
}aAL;

void Test(bool Function);
bool InitList(aAL *aal, int len);//初始化---len表示指定的容量
void DestroyList(aAL *aal);//只要释放给数组的空间，实际元素个数和容量都置为0
void ClearList(aAL *aal);
bool ListEmpty(aAL *aal);
int ListLength(aAL *aal);
bool GetElem(aAL *aal, int i, int *e);
int LocateElem(aAL *aal, int e);//成功返回e对应的下标,否则返回-1
bool PriorElem(aAL *aal, int e, int *Pre_e);
bool NextElem(aAL *aal, int e, int *Next_e);
bool ListInsert(aAL *aal, int i, int e);
bool ListDelete(aAL *aal, int i, int *e);
void ListTraverse(aAL *aal);

int main(void)
{
	//--------------链表的初始化
	//aAL *aTest = NULL;
	aAL aTest;
	int len;
	int i, e;//e是当前元素的值 i是第i个元素的下标

	printf("请输入你想要的数组的容量:");
	scanf("%d", &len);
	printf("InitList:");
	Test(InitList(&aTest, len));
	ListTraverse(&aTest);

	//------------在链表中的第i个位置插入一个元素并使长度加1
    //printf("请输入当前要插入元素的值:");
    //scanf("%d", &e);
  ListInsert(&aTest, 0, 10);
	ListInsert(&aTest, 0, 20);
	ListInsert(&aTest, 0, 30);
	ListInsert(&aTest, 0, 40);
	ListInsert(&aTest, 0, 50);
	ListTraverse(&aTest);

	//-------------链表的销毁
    //DestroyList(aTest);

    //------------链表的清空
    //ClearList(aTest);

    //------------判断链表是否为空
	printf("ListEmpty:");
    Test(ListEmpty(&aTest));
	ListTraverse(&aTest);

    //------------测链表的长度
    printf("链表的当前长度为: %d\n", ListLength(&aTest));
	ListTraverse(&aTest);

    //------------返回第i个元素的值
    
    printf("请输入要得到元素的下标:");
    scanf("%d", &i);
    GetElem(&aTest, i, &e);
    printf("当前元素是: %d\n", e);
	ListTraverse(&aTest);

    //------------返回当前元素的下标
    printf("请输入当前元素的值来得到其下标:");
    scanf("%d", &e);
    printf("当前元素的下标是: %d\n", LocateElem(&aTest, e));
	ListTraverse(&aTest);

    //------------找到当前元素的直接前驱的值
    int Pre_e;
    printf("请输入当前元素的值来找直接前驱的值:");
    scanf("%d", &e);
    Test(PriorElem(&aTest, e, &Pre_e));
	printf("直接前驱的值: %d\n", Pre_e);
	ListTraverse(&aTest);

    //------------找到当前元素的直接后继的值
    int Next_e;
    printf("请输入当前元素的值来找直接后继的值:");
    scanf("%d", &e);
    Test(NextElem(&aTest, e, &Next_e));
	printf("直接后继的值: %d\n", Next_e);
	ListTraverse(&aTest);


    //------------在链表中的第i个位置插入一个元素并使长度加1
    printf("请输入当前要插入元素的值和它的下标:");//e是当前元素的值 i是第i个元素的下标
    scanf("%d%d", &e, &i);
    ListInsert(&aTest, i, e);
	ListTraverse(&aTest);


    //------------在链表中的第i个位置删除一个元素并使长度减1
    printf("请输入当前要删除元素的下标:");
    scanf("%d", &i);
    ListDelete(&aTest, i, &e);
	printf("你删除的数是:%d\n", e);
	ListTraverse(&aTest);

	//-------------------------------
	return 0;
}

void Test(bool Function)
{
    if (Function)
        printf("SUCCESS\n");
    else
        printf("FAIL\n");
}

bool InitList(aAL *aal, int len)
{
    aal->iLength = 0;//实际的元素个数
    aal->iSize = len;//容量
	aal->aArray = (ElemType *)malloc(sizeof(ElemType) * len);//分配len个的(ElemType * )类型的空间大小给实际的数组
   
	if (aal->aArray == NULL)//分配失败返回false
        return false;
    else
        return true;
}
//只要释放给数组的空间，实际元素个数和容量都置为0
void DestroyList(aAL *aal)
{
    aal->iLength = 0;
    aal->iSize = 0;
    free(aal->aArray);//释放之后是一个野指针
    aal->aArray = NULL;//最好使其为空

}
//清空是将内容清除而销毁则是整张表都没有了
void ClearList(aAL *aal)
{
    aal->iLength = 0;
}
bool ListEmpty(aAL *aal)
{
    if (aal->iLength == 0)
        return true;
    else
        return false;
}
int ListLength(aAL *aal)
{
        return aal->iLength;
}
bool GetElem(aAL *aal, int i, int *e)
{
    if (i > ListLength(aal) || i < 0 )
        return false;
    else
    {
        *e = aal->aArray[i-1];
        return true;
    }

}
//成功返回e对应的下标,否则返回-1
int LocateElem(aAL *aal, int e)
{
    for (int i = 0; i < ListLength(aal); i++)
    {
        if (aal->aArray[i] == e)
            return i;
    }

    return -1;
}
//e表示当前元素
bool PriorElem(aAL *aal, int e, int *Pre_e)
{
    for (int i = 0; i < ListLength(aal); i++)
    {
        if ( e == aal->aArray[i])
        {
            if (i == 0)//第一个元素
            {
                return false;
            }
            else
            {
                *Pre_e = aal->aArray[i-1];
                return true;
            }
        }
    }//for

    return false;
}
//e表示当前元素
bool NextElem(aAL *aal, int e, int *Next_e)
{
    for (int i = 0; i < ListLength(aal); i++)
    {
        if ( e == aal->aArray[i])
        {
            if (i == (ListLength(aal) - 1) )//最后一个元素的下表为----ListLength(aal) - 1
            {
                return false;
            }
            else
            {
                *Next_e = aal->aArray[i+1];
                return true;
            }
        }
    }//for

    return false;
}
//e表示当前要插入的元素-----i是第i个元素的下标
bool ListInsert(aAL *aal, int i, int e)
{
    if (i < 0 || i > ListLength(aal))//先判断是否合法
        return false;

    if (aal->iLength == aal->iSize && aal->iSize != 0)//如果满了就扩大一倍--------aal->iLength == aal->iSize == 0为空 也可能
    {
        aal->aArray = (ElemType *)realloc(aal->aArray, sizeof(ElemType) * aal->iSize * 2);
        if (aal->aArray == NULL)//分配失败
            return false;
        else
            aal->iSize *= 2;
    }

    //插入部分
    for (int j = ListLength(aal); j > i; j--)
	{
        aal->aArray[j] = aal->aArray[j-1];
	}

    aal->aArray[i] = e;
    aal->iLength++;//优先级->大于++

    return true;
}
//e表示当前要删除的元素-----i是第i个元素的下标
bool ListDelete(aAL *aal, int i, int *e)
{
     if (i < 0 || i > ListLength(aal))//先判断是否合法
        return false;

    *e = aal->aArray[i];
    //删除部分
    for (int j = i; j < ListLength(aal); j++)
        aal->aArray[j] = aal->aArray[j+1];

    aal->iLength--;

    return false;
}
void ListTraverse(aAL *aal)
{
	
	if (aal->iLength == 0)
	{
		printf("当前没有元素\n");
	}
	else
	{
		printf("当前元素个数:%d\n当前元素是:", ListLength(aal));
		for (int j = 0; j < ListLength(aal); j++)//为了区别i这里使用j作为循环变量
		{
			printf("%d\t", aal->aArray[j]);
		}
		putchar(10);
	}
}