单向链表的数组实现

Note

使用的工具是CodeBlocks 16.01
没有实现元素无限添加
启用了C99标准

CodeBlocks启用C99支持

自己写着玩的

线性表是有序的序列{a₁,a₂,...,a_n}，元素与元素之间有前后（先后）的关系，对于其中的任一个元素a_i来说，其前面有且只有一个或零个元素，后面也是如此。这样一来，这个定义就可以使用在循环链表中了。

单向链表

双向的链表

循环的链表

array_list.h

定义了ArrayList结构体和可以对ArrayList及其元素进行的操作。

#include

#define DEFAULT_ARRAY_LIST_LEN 1024

typedef struct{
    int *pArray; // 指向数组的指针
    int totalLen; // 数组的总长度
    int increase; // 增长率
    int currentLen; //当前数组的长度
}ArrayList;

bool arrayListFull(const ArrayList * const pArray);
bool arrayListEmpty(const ArrayList* const pArray);
bool arrayListAppend(ArrayList *pArray,int e);
bool arrayListInsert(ArrayList* pArray,int i,int e);
int arrayListLen(const ArrayList*const pArray);
bool arrayListRemove(ArrayList* pArray,int index,int * e);
void arrayListShow(const ArrayList*const pArray);
void arrayListSort(ArrayList*pArray,bool rev);
void arrayListReverse(ArrayList*pArray);
bool arrayListContain(const ArrayList*const pArray,int e);
int arrayListIndex(const ArrayList* const pArray,int e);

array_list.c
array_list.h中定义的函数的实现代码。

#include
#include
#include
#include"array_list.h"

/** \brief 初始化ArrayList.
 *
 * \param pList:指向需要初始化的ArrayList的指针
 * \param length:ArrayList的长度。如果指定的长度小于或等于0，
                则默认为DEFAULT_ARRAY_LIST_LEN
 * \return 如果初始化成功，返回true。
 */
bool arrayListInit(ArrayList *pList,int length){
    if(length<=0){
        length = DEFAULT_ARRAY_LIST_LEN;
    }

    pList->pArray=(int *)malloc(sizeof(int)*length);// 动态分配内存

    if(pList->pArray!=NULL){
        pList->currentLen=0;
        pList->totalLen=length;
        return true;
    }

    printf("内存分配失败！\n");
    exit(-1);
}

/** \brief 在ArrayList的后面添加元素
 *
 * \param pArray：指向需要追加元素的ArrayList的指针
 * \param e：需要添加的元素
 * \return 如果添加成功则返回true，否则返回false
 */
bool arrayListAppend(ArrayList *pArray,int e){

    if(arrayListFull(pArray)){
        printf("ArrayList满了！\n");
        return false;
    }

    if(pArray!=NULL){
        pArray->pArray[pArray->currentLen]=e;
        pArray->currentLen++;
        return true;
    }

    printf("ArrayList没有初始化!\n");
    return false;
}

/** \brief 判断ArrayList是否满了
 *
 * \param pArray ArrayList* 需要判断的ArrayList对象的指针
 * \return bool 满了则返回true，否则返回false
 *
 */
bool arrayListFull(const ArrayList* const pArray){
    return pArray->currentLen==pArray->totalLen?true:false;
}

/** \brief 判断ArrayList是否为空
 *
 * \param pArray const ArrayList*const
 *          需要判断的ArrayList对象的指针
 * \return bool
 *          如果为空，则返回true，否则返回false
 */
bool arrayListEmpty(const ArrayList* const pArray)
{
    return pArray->currentLen==0?true:false;
}
/** \brief 往ArrayList中插入元素
 *
 * \param pArray ArrayList* 指向ArrayList对象的指针
 * \param i int 插入的位置，i>=0
 * \param e int 插入的元素
 * \return bool 如果插入成功则返回true，否则返回false
 *
 */
bool arrayListInsert(ArrayList* pArray,int index,int e)
{
    if(arrayListFull(pArray)){
        printf("ArrayList满了!\n");
        return false;
    }else{
        for(int i = pArray->currentLen;i > index;i--){
            pArray->pArray[i]=pArray->pArray[i-1];
        }
        pArray->pArray[index]=e;
        pArray->currentLen++;
        return true;
    }
}
/** \brief 求ArrayList的元素数量
 *
 * \param pArray const ArrayList*const 指向ArrayList对象的指针
 * \return int 返回ArrayList中元素的数量
 *
 */
int arrayListLen(const ArrayList*const pArray)
{
    return pArray->currentLen;
}
/** \brief 移除ArrayList中指定位置的元素，位置从0开始
 *
 * \param pArray ArrayList* 指向ArrayList对象的指针
 * \param index int 需要移除的位置
 * \param e int* 保存被移除的元素
 * \return bool 移除成功则返回true，否则返回false
 *
 */
bool arrayListRemove(ArrayList* pArray,int index,int * e)
{
    if(pArray==NULL){
        printf("ArrayList没有初始化!\n");
        return false;
    }
    if(arrayListEmpty(pArray)){
        printf("ArrayList是空的！\n");
        return false;
    }
    if(index<0 || index>pArray->currentLen-1){
        printf("下标越界!\n");
        return false;
    }
    *e = pArray->pArray[index];
    for(int i = index;icurrentLen;i++){
        pArray->pArray[i]=pArray->pArray[i+1];
    }
    pArray->currentLen--;
    return true;
}
/** \brief 输出ArrayList对象
 *
 * \param pArray const ArrayList*const 指向ArrayList的指针
 * \return void
 *
 */
void arrayListShow(const ArrayList*const pArray)
{
    if(arrayListEmpty(pArray)){
        printf("ArrayList是空的!\n");
        return;
    }
    for(int i = 0; i < pArray->currentLen;i++){
        printf("%d:%d\n",i+1,pArray->pArray[i]);
    }
    return;
}
/** \brief 对ArrayList进行升序排序
 *
 * \param ArrayList*pArray 指向ArrayList对象的指针
 * \param rev bool 是否降序
 * \return void
 *
 */
void arrayListSort(ArrayList*pArray,bool rev)
{
    if(arrayListEmpty(pArray)){
        printf("ArrayList是空的!\n");
        return;
    }
    for(int i = 0; i < pArray->currentLen;i++){
        for(int j = i+1;jcurrentLen;j++){
            if(pArray->pArray[j]pArray[i]){
                int temp = pArray->pArray[i];
                pArray->pArray[i]=pArray->pArray[j];
                pArray->pArray[j]=temp;
            }
        }
    }
    if(rev==true){
        arrayListReverse(pArray);
    }
    return;
}
/** \brief 原地翻转ArrayList
 *
 * \param ArrayList*pArray 指向ArrayList对象的指针
 * \return void
 *
 */
void arrayListReverse(ArrayList*pArray)
{
    if(arrayListEmpty(pArray)){
        return;
    }
    int s=0,e=pArray->currentLen-1,temp;
    while(spArray[s];
        pArray->pArray[s] = pArray->pArray[e];
        pArray->pArray[e]=temp;
        s++;
        e--;
    }
    return;
}
/** \brief 判断ArrayList中是否包含某个元素e
 *
 * \param pArray const ArrayList*const 指向ArrayList对象的指针
 * \param e int 要查找的元素
 * \return bool 如果包含该元素，则返回true，否则返回false
 *
 */
bool arrayListContain(const ArrayList*const pArray,int e)
{
    if(arrayListIndex(pArray,e)!=-1){
        return true;
    }
    return false;
}
/** \brief 得到元素e的index
 *
 * \param pArray const ArrayList*const 指向ArrayList对象的指针
 * \param e int 需要获取index的元素
 * \return int 返回e在ArrayList中的index，如果不存在，则返回-1
 *
 */
int arrayListIndex(const ArrayList* const pArray,int e)
{
    if(arrayListEmpty(pArray)){
        printf("ArrayList是空的!\n");
        return -1;
    }else{
        int len = pArray->currentLen;
        for(int i = 0;i < len;i++){
            if(pArray->pArray[i]==e){
                return i;
            }
        }
        printf("没有这个元素!\n");
        return -1;
    }
}

array_list_test.c
测试ArrayList的代码。

#include"array_list.h"
#include
#include

/** \brief 测试ArrayList的代码
 *
 * \param void
 * \return int
 *
 */
int main(void)
{
    ArrayList myList; // 创建ArrayList对象
    arrayListInit(&myList,400); // 初始化
    arrayListShow(&myList);

    // 追加元素
    arrayListAppend(&myList,56);
    arrayListAppend(&myList,32);
    arrayListAppend(&myList,24);
    arrayListAppend(&myList,12);
    arrayListAppend(&myList,58);
    arrayListShow(&myList);

    printf("-------\n");
    arrayListInsert(&myList,1,24); // 在指定的位置插入元素
    arrayListShow(&myList);

    printf("-------\n");
    int e;
    arrayListRemove(&myList,2,&e); // 删除指定位置的元素
    printf("被删除的元素是:%d\n",e);
    arrayListShow(&myList);

    printf("排序以后\n");
    arrayListSort(&myList,false);
    arrayListShow(&myList);

    printf("翻转\n");
    arrayListReverse(&myList);
    arrayListShow(&myList);

    printf("在第一个位置插入一个元素10\n");
    arrayListInsert(&myList,0,10);
    arrayListShow(&myList);
    return 0;
}

单向链表的数组实现

你可能感兴趣的:(单向链表的数组实现)