数据结构线性表的顺序表示和实现(C语言)概论

/*

线性结构，线性表的顺序表示和实现

*/

# include

# include

# include //包含了exit（）函数

//定义一个数组结构体

struct Arr

{

int * pBase; //保存数组的指针

int len; //保存数组的长度

int cnt; //数组元素的有效个数

};

//前置函数声明

void init_arr(struct Arr * pArr,int length); //初始化

bool append_arr(struct Arr * pArr,int val); //追加一个元素

bool insert_arr(struct Arr * pArr, int pos, int val); //插入一个元素

bool delete_arr(struct Arr * pArr, int pos, int * val); //删除数组中的一个元素int get(struct Arr * pArr, int pos); //获取某个元素的值

bool is_empty(struct Arr * pArr); //判断数组是否为空

bool is_full(struct Arr * pArr); //判断数组是否已满

void sort_arr(struct Arr * pArr); //为数组进行从小到大排序

void show_arr(struct Arr * pArr); //显示数组内容

void inversion_arr(struct Arr * pArr); //反转数组中的所有值

/*

创建一个数组，实现对这个数组的操作

1，追加一个元素

2，插入一个元素

3，对数组排序

4，反转数组元素

*/

int main(void)

{

//定义一个结构体变量

struct Arr array;

//获取一个被删除的元素的值

int val;

//使用函数init_arr()初始化数组

init_arr(&array, 5);

//追加一个元素

append_arr(&array, 5);

append_arr(&array, 3);

append_arr(&array, 7);

append_arr(&array, 1);

printf("初始化的数组为：\n");

show_arr(&array);

//使用函数insert_arr()插入一个元素

printf("在第三个元素前插入一个数值99：\n");

insert_arr(&array, 3, 99); //在第三个元素前，插入一个元素show_arr(&array);

//使用函数inversion_arr()对数组中的元素进行翻转

printf("反转数组中的所有值:\n");

inversion_arr(&array);

show_arr(&array);

//使用函数sort_arr()对数组进行排序

printf("将数组进行排序:\n");

sort_arr(&array);

show_arr(&array);

//使用函数delete_arr()删除一个元素

printf("删除数组中第三个元素:\n");

delete_arr(&array, 3, &val);

show_arr(&array);

//使用函数append_arr()追加一个元素

printf("在数组的最后追加一个数值50:\n");

append_arr(&array,50);

show_arr(&array);

//使用函数get()获得一个元素

printf("得到数组中第三个元素:\n%d\n",get(&array,3));

return 0;

}

/*

初始化数组

@param struct Arr * pArr 结构体变量指针@param int length 定义数组的长度return void

*/

void init_arr(struct Arr * pArr,int length)

{

pArr->pBase = (int *)malloc(sizeof(int) * length);

//判断动态内存是否创建成功

if( NULL == pArr->pBase)

{

printf("动态内存常见失败\n");

exit(-1);

}

//为其他元素赋值

pArr->len = length;

pArr->cnt = 0;

return; //标识此函数结束

}

/*

将数组展示出来

@param struct Arr * pArr 结构体变量指针return void

*/

void show_arr(struct Arr * pArr)

{

int i;

//首先判断这个数组是否有有效值

if( is_empty(pArr) )

{

printf("这个数组为空\n");

exit(-1);

}

else

{

for(i = 0; i < pArr->cnt; ++i)

{

printf("%d ", pArr->pBase[i]);

}

printf("\n");

}

}

/*

判断数组是否为空数组

@param struct Arr * pArr 结构体变量指针return Boolean

*/

bool is_empty(struct Arr * pArr)

{

if( 0 == pArr->cnt )

{

return true;

}

else

{

return false;

}

}

/*

追加一个元素

@param struct Arr * pArr 结构体变量指针@param int val 追加的元素的值return Boolean

*/

bool append_arr(struct Arr * pArr, int val)

{

if(is_full(pArr))

{

printf("该数组已满\n");

return false;

}

pArr->pBase[pArr->cnt] = val;

pArr->cnt++;

return true;

}

/*

判断数组是否已经爆满

@param struct Arr * pArr 结构体变量指针return Boolean

*/

bool is_full(struct Arr * pArr)

{

if( pArr->len == pArr->cnt){

return true;

}

else

{

return false;

}

}

/*

在数组中间插入一个元素

@param struct Arr * pArr 结构体变量指针

@param int pos 要插入元素的位置，不是下标@param int val 要插入元素的值

return Boolean

*/

bool insert_arr(struct Arr * pArr, int pos, int val)

{

int i;

if( is_full(pArr) )

{

printf("数组已满，无法插入\n");

return false;

}

for( i = pArr->cnt-1; i >= pos-1; --i )

{

pArr->pBase[i+1] = pArr->pBase[i];

}

pArr->pBase[pos-1] = val;

pArr->cnt++;

return true;

}

/*

删除数组中的一个元素

@param struct Arr * pArr 结构体变量指针

@param int pos 要删除的元素的位置，不是下标@param int * val 已删除元素的值

return Boolean

*/

bool delete_arr(struct Arr * pArr, int pos, int * val)

{

int i;

//判断数组是否为空，如果为空，就不用后续操作了

if( is_empty(pArr) )

{

printf("该数组为空，不能删除某值\n");

return false;

}

//判断传入的pos是否合法

if(pos < 1 || pos > pArr->cnt)

{

printf("需要删除的元素不存在\n");

return false;

}

//获取到要删除的元素值

*val = pArr->pBase[pos-1];

for(i = pos; i < pArr->cnt; ++i)

{

pArr->pBase[i-1] = pArr->pBase[i];

}

pArr->cnt--;

return false;

}

/*

为数组进行从小到大排序

@param struct Arr * pArr 结构体变量指针

return void

*/

void sort_arr(struct Arr * pArr)

{

//排序的方式很多，我也不知道这个方法叫什么名字

int i, j, t;

for( i = 0; i < pArr->cnt; ++i)

{

for(j = i+1; j < pArr->cnt; ++j)

{

if(pArr->pBase[i] > pArr->pBase[j])

{

t = pArr->pBase[i];

pArr->pBase[i] = pArr->pBase[j];

pArr->pBase[j] = t;

}

}

}

}

/*

为数组进行从小到大排序

@param struct Arr * pArr 结构体变量指针

return void

*/

void inversion_arr(struct Arr * pArr)

{

int i = 0;

int j = pArr->cnt-1;

int t;

while(i < j)

{

t = pArr->pBase[i];

pArr->pBase[i] = pArr->pBase[j];

pArr->pBase[j] = t;

i++;

j--;

}

}

/*

获取一个数组元素的值

@param struct Arr * pArr 结构体变量指针

@param int pos 要获取的元素位置return int val 所需要的值

*/

int get(struct Arr * pArr, int pos)

{

int i;

i = pArr->pBase[pos-1];

return i;

}

/*

VC++6.0 运行的结果是：

====================================== 初始化的数组为：

5 3 7 1

在第三个元素前插入一个数值99：

5 3 99 7 1

反转数组中的所有值:

1 7 99 3 5

将数组进行排序:

1 3 5 7 99

删除数组中第三个元素:

1 3 7 99

在数组的最后追加一个数值50:

1 3 7 99 50

得到数组中第三个元素:

7

====================================== */