数据结构-（2）--顺序表--代码实现

说明：主函数中的插入函数和删除函数第三个参数都为位置参数：offset

• main.c

#include<stdio.h>
#include"orderlist.h"

int main(){

LIST * pList = NULL;
//创建顺序表
pList = createOrderList();
if(NULL != pList)
printf("顺序表创建成功\n");

//插入表（头0
insert(pList,1,1);

//插入表（尾）
insert(pList,2,5);

//插入表（尾）
insert(pList,3,6);

//插入表（尾）
insert(pList,5,-1);

//插入表（中）
insert(pList,4,3);

//显示表
show(pList);

//修改表
alter(pList,666,4);
printf("----------------------\n");

//显示数据
show(pList);

//删除数据
int deleteData;
delete(pList,&deleteData,4);
printf("被删除的数据是:%d\r\n",deleteData);
printf("----------------------\n");

//显示数据
show(pList);
printf("----------------------\n");

//销毁表
destroy(pList);
printf("----------------------\n");

//显示数据
show(pList);
}

• list.c

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"orderlist.h"

//创建顺序表
LIST *  createOrderList(){
        LIST * pList = (LIST *)malloc(sizeof(LIST));
        //判断堆空间是否申请成功
        if(NULL == pList){
                printf("堆空间申请失败\n");
        }
        memset(pList,0,sizeof(LIST));
        printf("堆空间申请成功\n");
        return pList;
}

//插入表
int insert(LIST * pList,int data,int offset){
        //判断顺序表pList是否存在,是否已满，插入位置是否大于数组长度，是否
小于-1（末尾）
        if(NULL == pList
        || SIZE == pList->count
        || offset < TAIL){
                printf("栈可能不存在或者已满或者越界\n");
                return ERROR;
        }

        int i = 0;
        //判断插入位置
        if(HEAD == offset){
                for(i = pList->count-1;i>0;i--){
                        pList->data[i+1] = pList->data[i];
                }
                pList->data[0] = data;
                pList->count++;
                printf("头插成功\n");
                return SUCCESS;
        }else if(TAIL == offset || offset >= pList->count){
                pList->data[pList->count] = data;
                pList->count++;
                printf("尾插成功\n");
                return SUCCESS;
        }else{
                for(i = pList->count; i > offset ;i--){
                        pList->data[i] = pList->data[i-1];
                }
                pList->data[offset] = data;
                pList->count++;
                printf("中间插成功\n");
                return SUCCESS;
        }
}

//显示函数
int show(LIST * pList){
        //判断数序表pList是否存在
        if(NULL == pList){
                printf("顺序表找不到");
                return ERROR;
        }

        int i;
        //打印数据
        for(i = 0;i < pList->count;i++){
                printf("顺序表第%d",i);
                printf("个元素是：%d\n",pList->data[i]);
        }
        return SUCCESS;
}

//修改函数
int alter(LIST * pList,int data,int offset){
        //判断顺序表pList是否存在或者修改位置是否越界
        if(NULL == pList
        || offset >= pList->count){
                printf("顺序表不存在或者越界\n");
                return ERROR;
        }
        pList->data[offset] = data;
        return SUCCESS;
}

//删除函数
int delete(LIST * pList,int * deleteData,int offset){
        //判断顺序表首pList是否存在
        if(NULL == pList
        || offset >= pList->count){
        printf("顺序表不存在或删除位置为空\n");
        return ERROR;
        }
        //判断删除位置
        //尾删
        if(offset == pList->count-1){
                *deleteData = pList->data[pList->count-1];
                pList->count--;
                return SUCCESS;
        //中间删
        }else{
                int i;
                for(i = offset;i < pList->count;i++){
                        * deleteData = pList->data[offset];
                        pList->data[i] = pList->data[i+1];
                        return SUCCESS;
                }
        }
}

//销毁函数
int destroy(LIST * pList){
        //判断顺序表首地址是否为空
        if(NULL == pList){
                printf("顺序表不存在\n");
                return ERROR;
        }
        //释放表空间
        free(pList);
        pList = NULL;
        printf("销毁成功\n");
        return SUCCESS;
                                  

 

• list.h

#ifndef _ORDER_LIST_
#define _ORDER_LIST_

//宏定义一个SIZE指定数组的大小
#define SIZE 32

//定义一个顺序表结构体
struct order_list{
        int data[SIZE];
        int count;
};
typedef struct order_list LIST;

//定义一个枚举类型存储常量
enum cl{
//用作插入函数位置判断
HEAD = 1,
TAIL = -1,
//用作函数返回正确与否判断
SUCCESS = 0,
ERROR = -1,
};

//1----------声明顺序表创建函数
//返回类型为顺序表首地址pList
//参数类型无
LIST * createOrderList();

//2----------声明顺序表插入函数
//返回类型为int，与SUCCESS比较
//参数类型1：顺序表首地址pList
//参数类型2：插入数据
//参数类型3：参数插入位置
int insert(LIST * pList,int data,int offset);

//3-----------声明顺序表显示函数
//返回类型为int：与SUCCESS做比较
//参数类型1：顺序表首地址
int show(LIST * pLIst);

//4-----------声明顺序表的修改函数
//返回类型为int：与SUCCESS作比较
//参数类型1：数序表首地址pList
//参数类型2：修改的数据
//参数类型3：修改的位置
int alter(LIST * pList,int data,int offset);

//5-----------声明顺序表的删除函数
//返回类型为int：与SUCCESS做比较
//参数类型1：顺序表首地址pList
//参数类型2：主函数定义deleteData接收，函数返回值，打印被删除的数据
//参数类型3：删除位置
int delete(LIST * pList,int * deleteData,int offset);

//6-----------声明顺序表销毁函数
//返回类型为int：与SUCCESS做比较
//参数类型1：顺序表首地址pList
int destroy(LIST * pList);

#endif