数据结构——手写顺序表

• 前期准备：定义好相应的数据元素和顺序表结构

# define MAX_SIZE 255 //最大存储量

/**
 * 1. 定义数据元素
 */
typedef struct {
    int id;
    char *name;
} ElementType;

/**
 * 2. 定义顺序表结构
 */
typedef struct {
    ElementType datas[MAX_SIZE];  //顺序表中的数据元素集合
    int length; //当前顺序表中的元素个数
} SeqList;

• 插入元素

/**
 * 向顺序表中的index下标处插入某个元素
 * @param seqList
 * @param index     要插入的下标
 * @param elementType   要插入的元素
 */
void InsertElement(SeqList * seqList , int index,ElementType elementType){

    //1. 验证插入后的元素空间是否超过MAX_SIZE
    //2. index的值是否合法[0,MAX_SIZE]
    //3. 插入的index应该在length之内
    isOutOfRange(seqList,index);
    //4. 从第length-1个下标开始，前面一个元素赋值给后面一个元素
    for (int i = seqList->length -1 ; i >= index ; i -- ) {
         seqList->datas[i + 1] = seqList->datas[i];
    }

    //5. 将要插入的值赋值给第index个元素
    seqList->datas[index] = elementType;

    //6. 顺序表的总长度+1 ！！此处非常容易遗漏
    seqList->length ++ ;
}

• 初始化元素

/**
 * 初始化顺序表
 * @param seqList 要初始化的顺序表
 * @param elemArray   初始化时要添加的元素内容数组
 * @param length      初始化时添加的元素个数
 */
void InitList(SeqList * seqList ,ElementType * elemArray,int length){

    if(length > MAX_SIZE){
        printf("超出了数组的最大容量，初始化失败！\n");
        return;
    }
    seqList ->length = 0 ; // 初始化时记得长度归零
    for (int i = 0; i < length - 1; ++i) {
        //每次循环都在下标为i的位置插入一个元素
        InsertElement(seqList,i,elemArray[i]);
    }
}

• 删除元素

/**
 * 删除数组中的某一元素
 * @param seqList
 * @param index
 */
ElementType * deleteList(SeqList * seqList,int index){

    //1.判断是否越界
    isOutOfRange(seqList,index);

    //找到索引对应的值，并将之返回
    ElementType * delElement = (ElementType * )malloc(sizeof(ElementType));
    *delElement = *searchElem(seqList,index);

    //从index +1 处开始，后面一个覆盖前面一个
    for (int i = index ; i <= seqList -> length -1 ; ++i) {
        seqList ->datas[i] = seqList->datas[i+1];
    }

    //length减一
    seqList->length --;

    //使用完毕后进行free，否则会造成内存泄漏
    return delElement;
}

• 返回顺序表长度

/**
 * 返回顺序表长度
 * @param seqList
 * @return
 */
int getLength(SeqList * seqList){
    if(seqList == NULL){
        return 0;
    }
    return seqList->length;
}

• 判断是否为空

/**
 * 判断顺序表是否为空
 * @param seqList
 * @return
 */
int isEmpty(SeqList * seqList){
    return getLength(seqList) == 0 ? TRUE:FALSE;
}

• 清空顺序表

/**
 * 清空顺序表
 * @param seqList
 */
void clearList(SeqList * seqList){
    if(seqList == NULL) return;
    seqList->length = 0;
}

• 检查index是否越界

/**
 * 检验边界是否越界
 * @param seqList
 * @param index
 */
void isOutOfRange(SeqList * seqList,int index){
    //1. 验证插入后的元素空间是否超过MAX_SIZE
    if(seqList->length+1 > MAX_SIZE){
        printf("数组已满，插入元素失败！\n");
        return;
    }
    
    //2. index的值是否合法[0,MAX_SIZE]
    if(index < 0 || index > MAX_SIZE){
        printf("只能在允许的下标范围内插入元素[0，%d]\n");
        return;
    }
    
    //3. 插入的index应该在length之内
    if(index > seqList->length){
        printf("插入的下标超过了数组的最大长度-1，插入失败\n");
        return;
    }
}

• 查找元素

	/**
	 * 搜索并返回
	 * @param seqList
	 * @param index
	 * @return
	 */
	ElementType * searchElem(SeqList * seqList,int index){
	    //1. 判断下标是否越界
	    isOutOfRange(seqList,index);
	    //2. 找到对应下标的元素,并准备返回
	    return &seqList->datas[index];
	}

• 打印顺序表

	/**
	 * 打印顺序表数组
	 * @param seqList
	 */
	void PrintList(SeqList * seqList){

    for (int i = 0; i < seqList->length; ++i) {
        printf("%d\t%s\n",seqList->datas[i].id,seqList->datas[i].name);
    }
}

• 测试一下

	ElementType dataArray[] = {
	        {1,"祈风"},
	        {2,"美队"},
	        {3,"奇异博士"},
	        {4,"蓝轩宇"},
	        {5,"唐舞麟"}
	};


	void TestSeqList();
	int main() {
	    TestSeqList();
	    return 0;
	}

	void TestSeqList(){
	    SeqList  seqList ;
	    InitList(&seqList,dataArray,sizeof(dataArray) / sizeof(dataArray[0])+1);
	    PrintList(&seqList);
	    printf("********\n");
	    ElementType * ele = deleteList(&seqList,2);
	   printf("被删除的元素是：\n")
	    printf("%d\t%s\n",ele->id,ele->name);
	    printf("\n");
	    PrintList(&seqList);
	    printf("长度是****%d\n",seqList.length);
	    //释放资源
	    free(ele);
	}

• 结果
  

心得

• 实现顺序表，感觉有点像面向接口编程，首先我将那两个结构放在头文件，那些方法也放在另一个头文件，但是不去写它的实现，而是在另一个.c文件里引入头文件，然后实现它，这就有点像一个接口，而.c文件就相当于一个实现类，这样实现的话层次很清楚，而且在测试文件里我只可以导入头文件，具体的实现用户是看不到的，这样就是将你的代码封装了起来，安全性得到了保障。
• 下面看看我的结构
  头文件：
  
  一些没有实现的方法
  
  具体方法实现
  
  测试