二.学习数据结构之数组

线性结构（数组）

1.1 定义：元素类型相同，大小相等（数组传参，只要传进去首地址和长度就行）

1.2数组的优缺点：

优点：

存取速度快

缺点：

事先必须知道数组的长度

插入删除元素很慢

空间通常是有限制的

需要大块连续的内存块

插入删除元素的效率很低

1.3对数组的操作

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>//使用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 * pVal);
int get();
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);
int main(void)
{
struct Arr arr;//分配了内存空间，但是是垃圾数字，pBase是随机的一个地址
init_arr(&arr,10);//这就让内存的数字赋值了
int delVal;//删除的元素
//arr.pBase[0] = 1;
//arr.pBase[1] = 1;
//arr.pBase[2] = 1;
append_arr(&arr,8);
append_arr(&arr, 9);
append_arr(&arr, 4);
append_arr(&arr, 6);
//insert_arr(&arr, 2, 20);
//delete_arr(&arr, 3, &delVal);
show_arr(&arr);
/*printf("要删除的元素的值为：%d\n", delVal);*/
//inversion_arr(&arr);
sort_arr(&arr);
show_arr(&arr);
system("pause");
return 0;
}
void init_arr(struct Arr * pArr,int length)
{
pArr->pBase = (int *)malloc(sizeof(int)*length);
if (NULL == pArr->pBase)
{
printf("动态分配内存失败！\n");
exit(-1);
}
else
{
pArr->cnt = 0;
pArr->len = length;
}
return;
}

void show_arr(struct Arr * pArr)
{
if (is_empty(pArr))
{
printf("数组为空！\n");
}
else
{
for (int i = 0; i < pArr->cnt; i++)
printf("%d,", pArr->pBase[i]);
printf("\n");
}
}

bool is_empty(struct Arr * pArr)
{
if ( 0== pArr->cnt)
return true;
else
return false;
}

bool append_arr(struct Arr * pArr,int val)
{
if (is_full(pArr))
return false;
else
{
pArr->pBase[pArr->cnt] = val;
(pArr->cnt)++;
return true;
}
}

bool is_full(struct Arr * pArr)
{
if (pArr->cnt == pArr->len)
return true;
else
return false;
}

bool insert_arr(struct Arr* pArr, int pos, int val)
{
if (is_full(pArr))
return false;
if (pos<0||pos >pArr->cnt - 1)
{
return false;
}
else
{
for (int i = pos; i <pArr->cnt; i++)
{
pArr->pBase[i + 1] = pArr->pBase[i];
}
pArr->pBase[pos] = val;
(pArr->cnt)++;
return true;
}
}

bool delete_arr(struct Arr * pArr, int pos, int * pVal)
{
if (is_empty(pArr))
return false;
else if (pos<1 || pos>pArr->cnt - 1)
return false;
else
{
*pVal = (pArr->pBase[pos - 1]);//*pVal等价于val
for (int i = pos-1; i < pArr->cnt; i++)
{
pArr->pBase[i] = pArr->pBase[i+1];
}
(pArr->cnt)--;
return true;
}
}

void inversion_arr(struct Arr * pArr)
{
int i = 0;
int j = pArr->cnt-1;
int temp;
while (i<j)
{
temp = pArr->pBase[i];
pArr->pBase[i] = pArr->pBase[j];
pArr->pBase[j] = temp;
i++;
j--;
}
}

void sort_arr(struct Arr * pArr)
{
int i, j,temp;
//----------冒泡------------
/*for ( i = 0; i < pArr->cnt; i++)

for (j = 0;j < pArr->cnt - 1 - i;j++)
{
if (pArr->pBase[j]>pArr->pBase[j + 1])
{
temp = pArr->pBase[j];
pArr->pBase[j] = pArr->pBase[j+1];
pArr->pBase[j+1] = temp;
}
}*/
//--------选择排序----------
for (i = 0;i < pArr->cnt;i++)
for (j = i + 1;j < pArr->cnt;j++)
{
if (pArr->pBase[i]>pArr->pBase[j])
{
temp = pArr->pBase[i];
pArr->pBase[i] = pArr->pBase[j];
pArr->pBase[j] = temp;
}
}
}

1.4总结



1.5补充（关于malloc函数）



跨函数使用内存代码如下：

#include<stdio.h>
#include<malloc.h>
struct Student
{
int sid;
int age;
};
struct Student * CreateStruct(void);
void ShowStudent(struct Student *);
int main(void)
{
struct Student * pst;
pst = CreateStruct();
ShowStudent(pst);
}
struct Student * CreateStruct(void)
{
struct Student * p = (struct Student *)malloc(sizeof(struct Student));
p->sid = 88;
p->age = 44;
return p;
}
void ShowStudent(struct Student * p)
{
printf("%d %d\n", p->age, p->sid);
}

升级：

#include<stdio.h>
#include<stdlib.h>//system要用这个函数

void fun1(int * q);
void fun2(int ** q);
void fun3(int ** q);
int main()
{
int s = 5;
int * p=&s;
printf("p的值：%p\n", p);
//fun1(p);//通过这个函数改变p的值
//fun2(&p);
fun3(&p);//总结：跨函数使用内存必须动态分配内存才行；
printf("p的值：%p\n", p);
system("pause");
return 0;
}
void fun1(int * q)//1.这样改变不了必须是取p的地址（&p）才能改变
{
int s=6;
q = &s;
}

void fun2(int ** q)//2.这样*q = &s;的确是p指向了另一个地址，但是退出}就没有了指向了
{
int s = 6;
*q = &s;
}
void fun3(int ** q)//3.malloc函数动态分配内存，必须手动释放free（），操作系统才会回收内存，不然会内存丢失
{
*q =(int*) malloc(sizeof(int));//相当于int aa=new int();
}

注意：多维数组本质就是一维数组，具体见二维数组内存中保存