C语言实现动态链表结构

类似java中的ArrayList 实现一个长度变化的数组结构体，嗯，实现起来很简单，重要的是数组长度的增加的处理，数组中插入数据的元素移动以及删除时候的元素移动；
定义结构体

typedef struct ArrayList{
    int allLen; //数组总长度
    int nowlen;//数组现在的元素个数
    int * list;
}array;

然后是数组增删的算法：

/*
 * arrayList.c
 *
 *  Created on: 2017-9-14
 *      Author: Administrator
 *      建立一个动态存储数字的数组
 *      根据存储大小动态增加数组长度 关键是数组的赋值程序 和增量程序
 */
#include<stdio.h>
#include<stdlib.h>
#include"testhead.h"

void arrayTest() {
    array * arr = malloc(sizeof(array));
    arr->allLen = 5;
    arr->nowlen = 0;
    arr->list = malloc(5 * sizeof(int));
    insertEnd(arr, 1);
    insertEnd(arr, 2);
    insertEnd(arr, 3);
    insertEnd(arr, 4);
    insertEnd(arr, 6);
    insertEnd(arr, 7);
    deleIndex(5,arr);
    showArray(arr);
//  printf("%d",arr->allLen);

}
//无法遍历出没有赋予初始值的数组
void showArray(array* arr) {
    int i, j;
    int * list = arr->list;
    j = arr->nowlen;
    if (arr->nowlen == 0) {
        printf("there have no value");
        return;
    }
    for (i = 0; i < j; i++) {
        printf("the index%d is %d\n ", i, *(list + i));
    }

}
//插入第一个
void push(array*arr, int value) {
    insertIndex(0, arr, value);

}
//删除并弹出第一个
int pop(array*arr) {

    return deleIndex(0,arr);
}
//根据下标进行插入
void insertIndex(int index, array* arr, int value) {
    int * lt = arr->list;
    if (index > arr->allLen - 1) {
        //插入下标大于当前长度  应该返回错误，不过无所谓 也可以这么写，实际影响了删除
        int * newarry = malloc((index + 5) * sizeof(int));
        arr->allLen = index + 5;
        int i;
        for (i = 0; i < arr->nowlen; i++) {
            newarry[i] = lt[i];
        }
        newarry[index] = value;
        arr->nowlen += 1;
        arr->list = newarry;
        free(lt);

    } else {
        if (arr->nowlen < arr->allLen) {
            //所有index 大于index 这个值的，往后移动，首先从后面进行移动
            int i;
            for (i = arr->nowlen; i > -1; i--) {
                if (i >= index) {
                    lt[i + 1] = lt[i];
                }
            }
            arr->nowlen += 1;
            lt[index] = value;
        } else if (arr->nowlen == arr->allLen) {
            arr->allLen += 5;
            int * newArray = (int*) malloc((arr->allLen) * sizeof(int));
            int j;
            for (j = 0; j < arr->nowlen; j++) {
                if (j < index) {
                    newArray[j] = lt[j];
                } else {
                    newArray[index] = value;
                    newArray[j + 1] = lt[j];
                }

            }
//       int i;
//       for(i=arr->nowlen;i>-1;i--){
//         if(i>=index){
//             newArray[i+1]=newArray[i];
//         }
//       }
//       newArray[index]=value;
            arr->nowlen += 1;
            arr->list = newArray;
            free(lt);

        } else {
            printf("wrong");
        }
    }

}
//结尾进行插入
void insertEnd(array*arr, int value) {
    int i, j;
    int * lt;
    i = arr->allLen;
    j = arr->nowlen;
    lt = arr->list;
    if (j < i) {
        //当前量小于总量
        arr->nowlen += 1;
        lt[j] = value;

    } else if (j == i) {
        //数组满了的情况 对数组进行增加容量，然后复制值， 然后改变指针，然后回收之前的数组
        arr->allLen = i + 5;
        arr->nowlen += 1;
        int * newArray = (int*) malloc((i + 5) * sizeof(int));//每次增加5个byte
        int k;
        for (k = 0; k < j; k++) {
            newArray[k] = lt[k];
        }
        newArray[i] = value;
        arr->list = newArray;
        free(lt);
    } else {
        printf("wrong");
    }

}

//根据下标进行删除  删除之后，
int deleIndex(int index, array*arr) {
    if (index > arr->nowlen - 1) {
        //删除大于当前长度时候直接报错
        printf("wrong,with no this value");
        return -1;
    } else {
        int i;
        int value = arr->list[index];
        //直接通过赋值将之前的值覆盖
        for (i = index; i < arr->nowlen; i++) {
            arr->list[i] = arr->list[i + 1];
        }
        arr->nowlen-=1;
        return value;
    }

    return -1;
}