数组思维导图梳理

数组的基本组成

数组定义格式

数组：数组(array)是一种用于存储多个相同类型数据的存储模型

格式：数据类型 [ ] 变量名或者 数据类型 变量名[ ]

数组初始化

所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度

数组元素访问

数组变量访问方式

格式：数组名

数组内部保存的数据的访问方式

格式：数组名[索引]

索引：索引是数组中数据的编号方式

作用：索引用于访问数组中的数据使用，数组名[索引]等同于变量名，是一种特殊的变量名

数组操作的两个常见小问题

索引越界：访问了数组中不存在的索引对应的元素，造成索引越界问题

空指针异常：访问的数组已经不再指向堆内存的数据，造成空指针异常

数组中常用的快速排序，选择排序，冒泡排序

快速排序

快速排序

1.先从数列中取出一个数作为基准数。

2.分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。

3.再对左右区间重复第二步，直到各区间只有一个数。

//快速排序 左右指针法

void QuickSort(int* arr, int begin, int end)

{

//只有一个数或区间不存在

if (begin >= end)

return;

int left = begin;

int right = end;

//选左边为key

int keyi = begin;

while (begin < end)

{

//右边选小 等号防止和key值相等 防止顺序begin和end越界

while (arr[end] >= arr[keyi] && begin < end)

{

--end;

}

//左边选大

while (arr[begin] <= arr[keyi] && begin < end)

{

++begin;

}

//小的换到右边，大的换到左边

swap(&arr[begin], &arr[end]);

}

swap(&arr[keyi], &arr[end]);

keyi = end;

//[left,keyi-1]keyi[keyi+1,right]

QuickSort(arr, left, keyi - 1);

QuickSort(arr,keyi + 1,right);

}

时间复杂度：最坏情况：O(N^2)

      最好情况：O(N^2)

选择排序

1.首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

2.再从剩余未排序元素中继续寻找最小（大）元素，然后放到未排序序列的起始位置。

3.重复第二步，直到所有元素均排序完毕。

//选择排序

void swap(int* a, int* b)

{

int tem = *a;

*a = *b;

*b = tem;

}

void SelectSort(int* arr, int n)

{

//保存参与单趟排序的第一个数和最后一个数的下标

int begin = 0, end = n - 1;

while (begin < end)

{

//保存最大值的下标

int maxi = begin;

//保存最小值的下标

int mini = begin;

//找出最大值和最小值的下标

for (int i = begin; i <= end; ++i)

{

if (arr[i] < arr[mini])

{

mini = i;

}

if (arr[i] > arr[maxi])

{

maxi = i;

}

}

//最小值放在序列开头

swap(&arr[mini], &arr[begin]);

//防止最大的数在begin位置被换走

if (begin == maxi)

{

maxi = mini;

}

//最大值放在序列结尾

swap(&arr[maxi], &arr[end]);

++begin;

--end;

}

}

时间复杂度：最坏情况：O(N^2)

      最好情况：O(N^2)

空间复杂度：O(1)

冒泡排序

1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2.每趟从第一对相邻元素开始，对每一对相邻元素作同样的工作，直到最后一对。

3.针对所有的元素重复以上的步骤，除了已排序过的元素(每趟排序后的最后一个元素)，直到没有任何一对数字需要比较。

//冒泡排序

void BubbleSort(int* arr, int n)

{

int end = n;

while (end)

{

int flag = 0;

for (int i = 1; i < end; ++i)

{

if (arr[i - 1] > arr[i])

{

int tem = arr[i];

arr[i] = arr[i - 1];

arr[i - 1] = tem;

flag = 1;

}

}

if (flag == 0)

{

break;

}

--end;

}

}

时间复杂度：最坏情况：O(N^2)

      最好情况：O(N)

空间复杂度：O(1)