本文聚焦于C/C++中数组的相关知识。介绍了数组概述、定义格式，通过案例展示使用操作，指出常见错误，阐述循环与数组的关系。重点讲解数组作为函数参数的要求，还详细介绍了数组相关操作及算法，如查找元素下标、排序、二分法查询等。
数组【重点】
文章目录
- 数组【重点】
- 1.数组概述
- 2.C 语言数字定义格式
- 3.数组案例和使用操作
- 4.数组操作常见错误
- 5.循环和数组不得不说的关系
- 6.数组作为函数参数【重点】
- 7.数组相关操作实现/算法实现【重点】
- 7.1数组相关算法概述
- 7.2找出指定元素在数组中的下标位置
- 7.3找出指定元素在数组中最后一次出现的下标位置
- 7.4找出数组中最大元素所在下标位置
- 7.5找出数组中最小元素所在下标位置
- 7.6数组元素逆序
- 7.7使用指定元素，替换指定下标元素
- 7.8使用新元素，替换数组中指定的老元素
- 7.9用户指定起始下标和终止下标位置，截取数组中的数据内容，得到新数组
- 7.10数组中指定下标位置添加元素★
- 7.11删除数组中指定下标元素★
- 7.12删除数组中所有指定元素★
- 7.13 添加新数组内容到当前数组★
- 7.14 找出指定元素在数组中所有下标位置，存储到另一个数组中★
- 7.15 冒泡排序
- 7.16 选择排序
- 7.17 快速排序【难点重点】
- 7.18 二分法查询
- 7.15 冒泡排序
- 7.16 选择排序
- 7.17 快速排序【难点重点】
- 7.18 二分法查询
1.数组概述
2.C 语言数字定义格式
// 格式 数组类型 数组名称[常量容量] = {满足数据类型要求的初始化数据}； //数据类型 * 数组名 = new 数据类型[容量];(c++)
数据类型：明确告知当前数组存储的数据类型是哪一个类型，要求存放的数据只能是当前数据类型，严格遵守数据类型一致化原则。
数组名：操作数组使用的对应名称
1.数组名在一定范围以内具备唯一性
2.数组名是一个【指针变量】，存储当前数组在内存中的【首地址】
{常量容量}：决定当前数组的容量，允许最多多少个指定数据类型存储，并且数组容量一旦确定无法修改
- 如果使用的版本为 C89 版本，当前数组容量有且只支持常量形式，不允许存在变量情况。
- 如果使用的版本为 C99 以上，数组容量可以支持变量形式，允许后续代码提供对应的容量数据。
满足数据类型要求的初始化数据：数组在使用之前，必须保证首先进行对应的赋值操作。
3.数组案例和使用操作
数组案例
int arr[10] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
数组操作【重点】
需要通过数组名【有效下标】的方式操作数组中每一个下标对应的元素。
【有效下标】
从 0 开始到数组的容量 -1
例如：
int arr[10] 容量为 10 的数组，对应的有效下标范围是 0 ~ 9，超出对应下标范围，操作越界，非法的！！！有可能会导致【段错误(核心已转储)】
比较常用的非法下标 -1，使用非法下标常用于提示代码中操作存在一定问题。
#include <stdio.h>
int main(int argc,char * argv[])
{
/*
数组格式
数据类型 数组名[常量容量] = {满足数据类型要求初始化数据};
*/
int arr[10] = {1, 3, 5, 7, 9, 2, 4 ,6, 8, 10};
//取值数组 arr 中下标为 5 的元素进行赋值操作
peintf("arr[5] = %d\n",arr[5]);
//给予数组中下标为 5 的元素进行赋值操作
arr[5] = 200;
printf("arr[5] = %d\n",arr[5]);
}
4.数组操作常见错误
#include <stdio.h>
int main(int argc,char * argv[])
{
int arr[10];
//数组中的元素未赋值的情况下直接使用，存在【野值隐患】
printf("arr[5] = %d\n",arr[5]);
//以下两个操作都是数组下标越界问题，有可能存在数据内容，也有可能会导致
//段错误(核心已转储)，避免数组操作下标越界！！！
printf("arr[10] = %d\n",arr[10]);
printf("arr[-1] = %d\n",arr[-1]);
}
5.循环和数组不得不说的关系
数组和 for 循环之间关系非常密切
for(循环条件初始化；循环条件判断；循环条件修改)
{}
循环条件初始化 从数组下标 0 开始
循环条件判断 限制循环变量在有效下标范围以内
循环条件修改 步进关系/递增关系为 1
for 循环操作数组，完成赋值和取值的案例
#include <stdio.h>
int main(int argc, char const *argv[])
{
//定义了一个 int 类型数组，容量为 10 ，数组名为 arr
//同时采用{0}方式对于数组中元素进行必要的初始化操作
int arr[10] = {0};
//【模块1】for 循环给予数组中每一个元素进行赋值操作
for (int i = 0; i < 10; i++)
{
//使用 2 * i 数据赋值数组下标为 i 的元素
arr[i] = 2 * i;
}
//【模块2】for 循环遍历整个数组，展示数组中每一个元素存储的数据情况
for (int i = 0; i < 10; i++)
{
printf("arr[%d] = %d\n",i,arr[i]);
}
return 0;
}
6.数组作为函数参数【重点】
C/C++要求，如果数组作为函数的参数，必须提供一组数据/两个参数
- 数组本身
- 数组对应的容量
#include <stdio.h>
/*
给予 int 类型数组进行赋值操作函数
@param arr 用户提供的 int 类型数组
@param capacity 用户提供数组的容量
*/
void assign_int_array(int arr[],int capacity);
/*
在控制台展示用户提供的 int 类型数组
@param arr 用户提供的 int 类型数组
@param capacity 用户提供数组的容量
*/
void print_int_array(int arr[],int capacity);
int main(int argc, char const *argv[])
{
int arr[10] = {0};
/*
调用形式参数为数组类型的数组
需要提供给函数的实际参数
1.数组名 ==> 提供了整个数组
2.数组容量 ==> 作为限制数组操作下标范围的条件
*/
assign_int_array(arr,10);
print_int_array(arr,10);
return 0;
}
void assign_int_array(int arr[],int capacity)
{
for (int i = 0; i < capacity; i++)
{
arr[i] = 2 * i;
}
}
void print_int_array(int arr[],int capacity)
{
for (int i = 0; i < capacity; i++)
{
printf("arr[%d] = %d\n",i,arr[i]);
}
}
7.数组相关操作实现/算法实现【重点】
7.1数组相关算法概述
需要完成搜索，指定下标数据获取
- 指定元素搜索，指定下标数据获取
- 添加数据，删出数据，指定下标添加，指定下标删除
- 多数据信息获取，多数据信息删除/添加
- 数组扩容机制
- 排序操作【选择，冒泡，快速排序】
7.2找出指定元素在数组中的下标位置
int arr[10] = {1, 3, 5, 7, 9, 2, 5, 6, 8, 10};
/*
在数组中搜索
搜素指定元素 5，对应下标 2
搜索指定元素 6，对应下标 7
搜索指定元素 20，返回结果 -1【告知调用者，目标数据不存在！！！】
对于结果
1. 如果结果大于等于 0 表示目标数据在数组中存在
2. 如果结果为 -1 表示对应数据不存在。
*/
#include <stdio.h>
int main(int argc, char const *argv[])
{
// 查询数据的目标数组
int arr[10] = {1, 3, 5, 7, 9, 2, 5, 6, 8, 10};
// 用户指定的查询目标数据
int num = 5;
// 搜索功能模块
/*
1. 定义一个 int 类型变量 index ，用于存储指定目标数据下标位置，并且
当前变量初始化为 -1，如果在循环搜索过程中，找到目标元素，index 存储
对应下标位置，如果没有找到 index 依然是 -1
后续代码中就可以利用 index 数据存储情况进行判断
· index 如果大于等于 0 表示找到目标数据
· index 存储结果为 -1 表示目标数据不存在
【标记思想】
*/
int index = -1;
// 2. 利用 for 循环遍历整个数组，利用 if 判断，找出目标元素
for (int i = 0; i < 10; i++)
{
/*
利用 if 判断，如果目标元素和当前数组对应下标元素一致
index 存储对应下标位置，并且使用 break 跳出循环结构
*/
if (num == arr[i])
{
index = i;
break;
}
}
// 可以根据 index 的数据结果判断对应元素是否存在
if (index > -1)
{
printf("目标元素所在下标位置: %d\n", index);
}
else
{
printf("指定元素不存在!\n");
}
return 0;
}
7.3找出指定元素在数组中最后一次出现的下标位置
int arr[10] = {1, 3, 5, 7, 9, 2, 5, 6, 8, 10};
/*
在数组中搜索
搜素指定元素 5，最后一次出现的下标 6
搜索指定元素 6，对应下标 7
搜索指定元素 20，返回结果 -1【告知调用者，目标数据不存在！！！】
对于结果
1. 如果结果大于等于 0 表示目标数据在数组中存在
2. 如果结果为 -1 表示对应数据不存在。
*/
#include <stdio.h>
int main(int argc, char const *argv[])
{
//查询数据的目标数组
int arr[10] = {1, 3, 5, 7, 9, 2, 5, 6, 8, 10};
//用户指定的数据
int num = 5;
// 定义一个 int 类型变量 index 初始化为 -1 【标记变量】
// 如果找到目标元素，index 最终结果大于 -1 ，否则 index 依然是 -1
int index = -1;
//2.逆序遍历整个数组，从最大有效下标位置开始到 0 结束
for (int i = 10 - 1; i >= 0; i--)
{
// 找到目标元素，index 存储对应下标位置开始，到 0 结束
if(num == arr[i])
{
// 找到目标元素， index 存储对应下标位置，并且break 终止循环
index = i;
break;
}
}
// 根据 index 的数据存储情况，判断目标数据是否找到
if(index > -1)
{
printf("目标元素所在数组中出现最后一次的下标位置: %d\n",index);
}
else
{
printf("指定元素不存在！\n");
}
return 0;
}
7.4找出数组中最大元素所在下标位置
int arr[10] = {1, 3, 5, 7, 19, 2, 5, 6, 8, 10};
/*
找出数组中最大值所在的下标位置，数据查询的范围是当前数据中的所有元素，不得使用其他数据参与当前的搜索操作。
整个程序开始，以数组中下标为 0 的元素作为参照物，遍历整个数组，进行两两比较，每一次比较的结果，留存较大值对应的下标位置。
*/
#include <stdio.h>
int main(int argc, char const *argv[])
{
// 查询最大值所在下标位置的目标数组
int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// 1.准备一个变量，用于存储最大值对应的下标位置，当前变量初始化为 0
// 以下标为 0 的元素作为出初始化参照物。
int index = 0;
// 2.遍历整个数组，利用 if 判断进行两两比较，index 保留较大值下标
/*
index 初始化为 0 ，如果循环变量 i 从 0 开始，在 if 条件判断过程中
相当于 arr[10] < arr[0] 无效意义，遍历操作，循环开始条件从
index + 1 开始
*/
for (int i = 1; i < 10; i++)
{
// 当前 index 下标对应的元素，小于下标i 对应的元素
if(arr[index] < arr[i])
{
index = i;
}
}
// 以上操作结束，可以 100% 确定 index 存储的下标位置就是整个数组中
// 最大值对应的下标位置【找极值】
printf("该数组中最大元素的下标位置为: %d\n",index);
return 0;
}
7.5找出数组中最小元素所在下标位置
#include <stdio.h>
int main(int argc, char const *argv[])
{
// 查询最小值所在下标位置的目标数组
int arr[10] = {1, 3, 5, 71, 19, 2, 105, 6, 8, 10};
// 1. 准备一个变量，用于存储最大值对应的下标位置，当前变量初始化为 0
// 以下标为 0 的元素作为初始化参照物。
int index = 0;
// 2. 遍历整个数组，利用 if 判断进行两两比较，index 保留较小值下标
/*
index 初始化为 0，如果循环变量 i 从 0 开始，在 if 条件判断过程中
相当于 arr[0] > arr[0] 无效无意义，遍历操作，循环开始条件从
index + 1 开始
*/
for (int i = index + 1; i < 10; i++)
{
// 当前 index 下标对应的元素，大于下标 i 对应的元素
if (arr[index] > arr[i])
{
// index 存储 i 数据
index = i;
}
}
printf("最小值对应的下标位置: %d\n", index);
return 0;
}
7.6数组元素逆序
int arr[10] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
逆序之后的数据
arr ==> {10, 8, 6, 4, 2, 9, 7, 5, 3, 1};
数据交换位置的次数 = 数组容量 / 2
/*
数组元素逆序
int arr[10] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
逆序之后的数据
arr ==> {10, 8, 6, 4, 2, 9, 7, 5, 3, 1};
数据交换位置的次数 = 数组容量 / 2
*/
#include <stdio.h>
/*
在控制台展示用户提供的 int 类型数组
@param arr 用户提供的 int 类型数组
@param capaxity 用户提供数组的容量
*/
void print_int_array(int arr[], int capacity);
int main(int argc, char const *argv[])
{
// 数据逆序操作的原数组
int arr[10] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
print_int_array(arr, 10);
// 直接利用循环对数组中的元素进行逆序操作
for (int i = 0; i < 10 / 2; i++)
{
int temp = arr[i];
arr[i] = arr[10 - 1 - i];
arr[10 - 1 - i] = temp;
}
print_int_array(arr, 10);
return 0;
}
void print_int_array(int arr[], int capacity)
{
for (int i = 0; i < capacity; i++)
{
printf("arr[%d] = %d\n", i, arr[i]);
}
}
7.7使用指定元素，替换指定下标元素
int arr[10] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
/*
用户指定替换元素的下标位置 5，替换使用的新元素 20，最终结果
1. 需要知晓被替换的元素情况
2. 数组的数据内容替换之后
{1, 3, 5, 7, 9, 20, 4, 6, 8, 10}
【隐含一定的条件约束】
对用户提供的下标数据进行合法性判断
*/
/*
用户指定替换元素的下标位置 5 ,替换使用的新元素 20 ，最终结果
1.需要知晓被替换的元素情况
2.数组的数据内容替换之后
{1, 3, 5, 7, 9, 20, 4, 6, 8, 10}
*/
#include <stdio.h>
// C 语言标准库头文件
#include <stdlib.h>
/*
在控制台展示用户提供的 int 类型数组
@param arr 用户提供的 int 类型数组
@param capaxity 用户提供数组的容量
*/
void print_int_array(int arr[],int capacity);
int main(int argc, char const *argv[])
{
// 替换数据的原数组
int arr[10] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
// 用户指定替换的下标位置
int num = 20;
// 用户替换使用的数据
int index = 5;
//1.【重点】 用户指定下标位置合法性判断
if(index > 10 - 1 || index < 0)
{
printf("用户提供的下标数据非法！\n");
return EXIT_FAILURE;
}
// 2.首先取值被替换下标位置的元素数据情况
int temp = arr[index];
// 3，使用新数据直接替换原本的数据内容
arr[index] = num;
printf("被替换的arr[%d]元素内容为: %d\n",index,temp);
return temp;
print_int_array(arr,10);
return 0;
}
void print_int_array(int arr[],int capacity)
{
for(int i = 0;i < 10 ;i++)
{
printf("arr[%d] = %d\n",i, arr[i]);
}
}
7.8使用新元素，替换数组中指定的老元素
int arr[10] = {1, 3, 5, 1, 3, 5, 1, 3, 5, 1};
/*
用户指定替换的老元素为 1，替换使用的新元素为 10
最终替换之后的结果为
{10, 3, 5, 10, 3, 5, 10, 3, 5, 10}
*/
/*
int arr[10] = {1, 3, 5, 1, 3, 5, 1, 3, 5, 1};
用户指定替换的老元素为 1 , 替换使用的新元素为 20
最终替换之后的结果为
{10, 3, 5, 10, 3, 5, 10, 3, 5, 10}
*/
#include <stdio.h>
/*
在控制台展示用户提供的 int 类型数组
@param arr 用户提供的 int 类型数组
@param capacity 用户提供数组的容量
*/
void print_int_array(int arr[],int capacity);
int main(int argc, char const *argv[])
{
// 替换数据的原数组
int arr[10] = {1, 3, 5, 1, 3, 5, 1, 3, 5, 1};
// 用户指定的原(old)数据
int old_num = 1;
// 用户指定的新(new)数据
int new_num = 10;
// 1.直接利用循环遍历整个数组，找出目标 old_num元素
for (int i = 0; i < 10; i++)
{
// 下标为 i 的元素数据和 old_num一致
if (arr[i] == old_num)
{
arr[i] = new_num ;
}
}
print_int_array(arr,10);
return 0;
}
void print_int_array(int arr[],int capacity)
{
for (int i = 0; i < capacity; i++)
{
printf("arr[%d] = %d\n",i,arr[i]);
}
}
7.9用户指定起始下标和终止下标位置，截取数组中的数据内容，得到新数组
int arr[10] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
/*
用户指定开始下标为 2，结束下标为 6，得到的新数组数据情况为
{5, 7, 9, 2}
【隐含一定的条件约束】
1. 截取数据，结束下标对应的元素在新数组中不存在，要头不要尾 [begin, end)
2. 用户指定的起始下标和终止下标必须在合法范围以内。
3. 需要根据用户提供的下标范围，创建一个新的数组，暂时使用 C99 以上版本能力，完成一个临时
的数组
*/
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
// 截取数据的原数组
int arr[10] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
// 用户指定的开始下标位置
int begin = 2;
// 用户指定的终止下标位置
int end = 6;
// 1. 判断用户指定的下标位置是否合法
if (begin > end || begin < 0 || begin > 10 - 1 || end < 0 || end > 10 - 1)
{
printf("用户提供的下标数据不合法!\n");
return EXIT_FAILURE;
}
// 2. 计算得到新数组容量，同时创建新的同数据类型数组
int new_capacity = end - begin;
int new_array[new_capacity];
// 3. 利用循环进行数据移动操作，从 begin 开始到 end 结束
// 要头不要尾 [begin, end)
/*
3.1 定义 int 类型变量 count，作为尾插法变量
a. 记录有效元素个数
b. 作为当前新数组存储数据的下标位置标记
*/
int count = 0;
// 3.2 for 循环从 begin 开始到 end 结束，提取数据内容
for (int i = begin; i < end; i++)
{
new_array[count++] = arr[i];
}
// 查询数据情况
print_int_array(new_array, count);
return 0;
}
7.10数组中指定下标位置添加元素★
int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
/*
要求:
1. 0 是无效元素，仅作为空位置占位使用，不要在添加数据过程中，添加数据 0
2. 添加数据 20 到下标为 6 的位置，数组中数据结果的情况
{1, 2, 3, 4, 5, 6, 20, 7, 8, 9}
*/
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
// 插入数据的目标数组，最后一个数据为 0 表示空位置
int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
// 用户指定插入数据的下标位置
int index = 3;
// 用户指定插入的数据
int num = 20;
print_int_array(arr, 10);
printf("-------------------------------------------------------\n");
// 1. 用户提供数据合法性判断
if (index < 0 || index > 10 - 1)
{
printf("提供的下标数据不合法!\n");
return EXIT_FAILURE;
}
// 2. 利用 for 循环移动数据内容，腾出对应的插入数据位置
/*
循环从数组中最后一个位置开始，到用户指定插入数据的下标位置结束
*/
for (int i = 10 - 1; i > index; i--)
{
arr[i] = arr[i - 1];
}
// 3. 用户指定下标位置赋值目标数据
arr[index] = num;
print_int_array(arr, 10);
return 0;
}
7.11删除数组中指定下标元素★
int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
/*
要求:
1. 0 是无效元素，仅作为空位置占位使用
2. 删除数组中下标为 6 的元素
a. 需要告删除的数据情况
b. 数组元素被删除之后的数据形式
删除下标 5
数据情况 {1, 2, 3, 4, 5, 7, 8, 9, 10, 0}
数据向前移动，同时原本最后一个有效元素位置 0 占位表示空
*/
/*
2.11 删除数组中指定下标元素
int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
要求:
1. 0 是无效元素，仅作为空位置占位使用
2. 删除数组中下标为 6 的元素
a. 需要告删除的数据情况
b. 数组元素被删除之后的数据形式
删除下标 5
数据情况 {1, 2, 3, 4, 5, 7, 8, 9, 10, 0}
数据向前移动，同时原本最后一个有效元素位置 0 占位表示空
*/
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
// 删除数据的目标数组
int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// 用户指定删除数据的下标位置
int index = 2;
print_int_array(arr, 10);
printf("-------------------------------------------------------\n");
// 1. 针对于用户指定的删除数据下标位置进行合法性判断
if (index < 0 || index > 10 - 1)
{
printf("用户提供的下标数据有误!\n");
return EXIT_FAILURE;
}
// 2. 将用户指定下标删除的数据提取，用户知晓目标下标，但是并
// 不知道下标对应的数据情况。
int temp = arr[index];
// 3. 利用循环从用户指定删除位置开始，到数组最后一个有效位置结束
// 执行循环，数据整体向前移动
for (int i = index; i < 10 - 1; i++)
{
arr[i] = arr[i + 1];
}
// 4. 原本最后一个有效元素位置赋值为 0，作为空位置
arr[10 - 1] = 0;
// 被删除的数据情况和目前数组中的数据情况
printf("被删除的数据 %d\n", temp);
print_int_array(arr, 10);
return 0;
}
7.12删除数组中所有指定元素★
int arr[10] = {1, 3, 5, 1, 3, 5, 1, 3, 5, 7};
/*
要求:
1. 0 是无效元素，仅作为空位置占位使用
2. 删除数组中所有指定元素，例如 删除数据 1，数组的数据情况
{3, 5, 3, 5, 3, 5, 0, 0, 0, 0}
*/
// C 语言项目头文件三贱客
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char const *argv[])
{
// 删除数据的目标数组
int arr[10] = {1, 3, 5, 1, 3, 5, 1, 3, 5, 1};
// 用户指定的目标删除元素
int num = 1;
print_int_array(arr, 10);
printf("-------------------------------------------------------\n");
/*
1. 【核心变量】
尾插法的特殊使用
a. 记录当前数组中有多少个不被删除的元素
b. 保留元素在数组中存储的下标位置标记
*/
int count = 0;
// 2. 利用 for 循环遍历整个数组，保留非目标删除元素
for (int i = 0; i < 10; i++)
{
if (arr[i] != num)
{
arr[count++] = arr[i];
}
}
// 内存设置/擦除函数 memset(void * ptr, char ch, int n);
memset(arr + count, 0, sizeof(int) * (10 - count));
// memset(&arr[count], 0, sizeof(int) * (10 - count));
print_int_array(arr, 10);
return 0;
}
7.13 添加新数组内容到当前数组★
int arr[10] = {1, 3, 5, 7, 9, 0, 0, 0, 0, 0};
int new_arr[3] = {2, 4, 6};
/*
要求
添加 new_arr 到 arr 下标为 3 的位置，最终 arr 数组数据形式
{1, 3, 5, 2, 4, 6, 7, 9, 0, 0};
*/
// C 语言项目头文件三贱客
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char const *argv[])
{
// 添加数据的 target 目标数组
int target_arr[10] = {1, 3, 5, 7, 9, 0, 0, 0, 0, 0};
// 添加数据的 source 源数组
int source_arr[3] = {2, 4, 6};
// 用户指定的下标位置
int index = 3;
// target 目标数组容量
int target_arr_capacity = 10;
// target 目标数组有效元素个数
int target_arr_size = 5;
// source 源数组容量
int source_arr_capacity = 3;
// source 源数组有效元素个数
int source_arr_size = 3;
/*
以上数组中有几个隐含条件
1. target 目标数组容量为 10 ，有效元素个数为 5
2. source 源数组容量为 3，有效元素个数为 3
*/
// 1. 用户指定下标位置合法性判断，控制的有效范围是 target 目标数组的有效
// 元素个数以内，允许的范围是 0 ~ 5
if (index < 0 || index > target_arr_size)
{
printf("用户指定下标数据不合法!\n");
return EXIT_FAILURE;
}
// 2. 需要确定 source 源数组容量 + target 目标数组有效元素个数 <= target 目标数组容量
if (source_arr_size + target_arr_size > target_arr_capacity)
{
printf("源数组和目标数组数据个数大于目标数组容量，越界！\n");
return EXIT_FAILURE;
}
// 3. 核心步骤一，target 目标数组从插入数据位置开始，根据 source 源数组
// 有效元素个数进行数据向后移动
for (int i = target_arr_size - 1; i >= index; i--)
{
// target 目标数组的移动下标是当前下标 i + source 源数组容量
target_arr[i + source_arr_size] = target_arr[i];
}
// 4. 核心步骤二，source 源数组数据根据用户指定下标位置，放入到 target 目标数组中
for (int i = 0; i < source_arr_size; i++)
{
target_arr[index++] = source_arr[i];
}
print_int_array(target_arr, target_arr_capacity);
return 0;
}
7.14 找出指定元素在数组中所有下标位置，存储到另一个数组中★
int arr[10] = {1, 3, 5, 1, 3, 5, 1, 3, 5, 1};
/*
要求
找出元素 1 在数组中出现的所有下标位置
{0, 3, 6, 9};
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char const *argv[])
{
// target 目标数组
int arr[10] = {1, 3, 5, 1, 3, 5, 1, 3, 5, 1};
// 用户指定的目标元素
int num = 1;
// 思路一: 空间换时间
// 准备一个和 target 目标数组容量一致的数组，循环一次解决问题
int index_arr1[10] = {0};
// 利用尾插法将数据存储到 index_arr1
int count = 0;
for (int i = 0; i < 10; i++)
{
if (num == arr[i])
{
index_arr1[count++] = i;
}
}
// 展示数据
print_int_array(index_arr1, count);
printf("------------------------------------------------\n");
// 思路二: 时间换空间
count = 0;
// 利用 for 循环找出目标元素个数
for (int i = 0; i < 10; i++)
{
if (num == arr[i])
{
count++;
}
}
// 根据 count 目标元素个数创建对应的数组，如果count 为 0 终止运行。
if (0 == count)
{
return EXIT_FAILURE;
}
int index_arr2[count];
// 在执行一次循环，找出目标数据所在的下标位置，存储到 index_arr2 中
count = 0;
for (int i = 0; i < 10; i++)
{
if (num == arr[i])
{
index_arr2[count++] = i;
}
}
print_int_array(index_arr2, count);
return 0;
}
7.15 冒泡排序
7.16 选择排序
7.17 快速排序【难点重点】
7.18 二分法查询
// 利用尾插法将数据存储到 index_arr1
int count = 0;
for (int i = 0; i < 10; i++)
{
if (num == arr[i])
{
index_arr1[count++] = i;
}
}
// 展示数据
print_int_array(index_arr1, count);
printf("------------------------------------------------\n");
// 思路二: 时间换空间
count = 0;
// 利用 for 循环找出目标元素个数
for (int i = 0; i < 10; i++)
{
if (num == arr[i])
{
count++;
}
}
// 根据 count 目标元素个数创建对应的数组，如果count 为 0 终止运行。
if (0 == count)
{
return EXIT_FAILURE;
}
int index_arr2[count];
// 在执行一次循环，找出目标数据所在的下标位置，存储到 index_arr2 中
count = 0;
for (int i = 0; i < 10; i++)
{
if (num == arr[i])
{
index_arr2[count++] = i;
}
}
print_int_array(index_arr2, count);
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
