[数据结构与算法] 线性表之数组基本操作代码实现详解

1
2
int num[10];

1
2
3
int size = 10;
int num[size];

1
2
3
// 为数组分配一个可以存储10个int数据的内存空间
int* p_int = (int*)malloc(sizeof(int) * 10);

1
2
free(p_int);

1
2
int num[] = {1, 2, 3};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <stdio.h>
// 全局域创建数组
int num1[3];
int num5[3] = {1};
void init_array()
{
// 自定义函数局部域
int num3[3];
int num4[3] = {1};
printf("自定义函数num3[1]: %dn", num3[1]);
printf("n打印数组创建时初始化，未被初始化的元素n");
printf("自定义函数num4[1]: %dn", num4[1]);
}
int main()
{
printf("打印数组创建时未初始化，数组的元素n");
printf("全局域num1[1]: %dn", num1[1]);
int num2[3];
printf("main函数num2[1]: %dn", num2[1]);
init_array();
printf("全局域num5[1]: %dn", num5[1]);
int num6[3] = {1};
printf("main函数num6[1]: %dn", num6[1]);
return 0;
}

1
2
3
4
5
6
7
8
9
打印数组创建时未初始化，数组的元素
全局域num1[1]: 0
main函数num2[1]: 0
自定义函数num3[1]: 21899
打印数组创建时初始化，未被初始化的元素
自定义函数num4[1]: 0
全局域num5[1]: 0
main函数num6[1]: 0

1
2
3
int arr[10];
int max_size = sizeof(arr)/sizeof(arr[0]);

1
2
3
4
5
6
7
8
9
10
11
12
13
// 以动态分配内存为例
typedef struct{
int* data;
// 数组的首地址
int
length;
// 数组的当前长度

int
maxSize;
// 数组最大容量大小
} Array;

1
2
3
4
5
6
7
8
9
10
11
bool insertBack(Array* array, int num)
{
if (array->length >= array->maxSize)
{
return false;
}
array->pData[array->length] = num;
array->length++;
return true;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
bool insert(Array* array, int index, int num)
{
if (array == NULL || array->pData == NULL || array->length > array->maxSize)
{
return false;
}
for (int i = array->length; i > index; i--)
{
array->pData[i] = array->pData[i-1];
}
array->length++;
array->pData[index] = num;
return true;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
bool removeWithIndex(Array* array, int index)
{
if (array == NULL || array->pData == NULL || array->length > array->maxSize)
{
return false;
}
for (int i = index+1; i < array->length; i++)
{
array->pData[i-1] = array->pData[i];
}
array->length--;
return true;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
bool removeWithValue(Array* array, int value)
{
if (array == NULL || array->pData == NULL || array->length > array->maxSize)
{
return false;
}
int tmpArray[array->length];
int j = 0;
for (int i = 0; i < array->length; i++)
{
if (array->pData[i] == value)
{
continue;
}
tmpArray[j++] = array->pData[i];
}
array->pData = tmpArray;
array->length = j;
return true;
}

1
2
3
4
5
6
7
8
9
// 下标
int arr[10];
arr[1] = 2;
int a = arr[1];
// 指针
int arr[10];
*arr = 2; // 等价于arr[0] = 2;
int a = *(arr+1); // 等价于a = arr[1];