数组和相关算法

数组

1. 数组概述

1.1 数组引入描述

水上乐园物品存放区

1.2 C 语言数组定义格式

// 格式
数据类型 数组名[常量容量] = {满足数据类型要求的初始化数据};

• 数据类型：明确告知当前数组存储的数据类型是哪一个类型，要求存放的数据只能是当前数据类型，严格遵守数据类型一致化原则。
• 数组名：操作数据使用的对应名称
  1. 数组名在一定范围以内具备唯一性
  2. 数组名是一个【指针变量】，存储当前数组在内存中的【首地址】
• [常量容量]：决定当前数组的容量，允许最多多少个指定数据类型存储，并且数组容量一旦确定，无法修改。
  • 如果使用的版本为 C89 版本，当前数组容量有且只支持常量形式，不允许存在变量情况
  • 如果使用的版本为 C99 以上，数组容量可以支持变量形式，允许后续代码提供对应的容量数据
• 满足数据类型要求的初始化数据：数组在使用之前，必须保证首先进行对应的赋值操作

2. 数组案例和使用操作

数组案例

int arr[10] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};

2.1 数组操作【重点】

需要通过 数组名[有效下标] 的方式操作数组中每一个下标对应的元素。

【有效下标】
	从 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 的元素数据展示
	printf("arr[5] = %d\n", arr[5]);
	
	// 给予数组中下标为 5 的元素进行赋值操作
	arr[5] = 200;

	printf("arr[5] = %d\n", arr[5]);
}

2.2 数组操作常见错误

#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]);
}

3. 数组和循环

数组和 for 循环之间关系非常密切

for (循环条件初始化; 循环条件判断; 循环条件修改) 
{}

循环条件初始化 从数组下标 0 开始
循环条件判断 限制循环变量在有效下标以内
循环条件修改 步进关系/递增关系为 1

for 循环操作数组，完成赋值和取值的案例

#include <stdio.h>

int main(int argc, char const *argv[])
{   
    // 定义了一个 int 类型数组，容量为 10，数组名为 arr
    // 同时采用 {0} 方式对于数组中元素进行必要初始化操作
    int arr[10] = {0}; 

    // 【模块一】for 循环给予数组中每一个元素进行赋值操作
    for (int i = 0; i < 10; i++)
    {
        // 使用 2 * i 数据赋值数组中下标为 i 的元素
        arr[i] = 2 * i;
    }

    // 【模块二】for 循环遍历整个数组，展示数组中每一个元素存储的数据情况
    for (int i = 0; i < 10; i++)
    {
        printf("arr[%d] = %d\n", i, arr[i]);
    }

    return 0;
}

4. 数组作为函数参数【重点】

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);

/*
argc:int
argv:char * []
    arg ==> argument 参数
    argc ==> argument count 参数个数
    argv ==> argument value 参数数据/参数值
        argv 是一个数组，存在多个数据

    argc 就是用于提示告知当前 argv 数组的容量
*/
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 < 10; i++)
    {
        // 使用 2 * i 数据赋值数组中下标为 i 的元素
        arr[i] = i * 2;
    }
}

void print_int_array(int arr[], int capacity)
{
    for (int i = 0; i < 10; i++)
    {
        printf("arr[%d] = %d\n", i, arr[i]);
    }
}

5. 数组相关算法实现【重点】

5.1 数组相关算法概述

需要完成基于数组的增删改查【CRUD】操作，需要完成的功能

• 指定元素搜索，指定下标数据获取
• 添加数据，删除数据，指定下标添加，指定下标删除
• 多数据信息获取，多数据信息删除/添加
• 数组扩容机制
• 排序操作【选择，冒泡，快速排序】

5.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;
}

5.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, 5, 10};
    // 用户指定的数据
    int num = 5;

    // 1. 定义一个 int 类型变量 index 初始化为 -1 【标记变量】
    // 如果找到目标元素，index 最终结果大于 -1，否则 index 依然是 -1
    int index = -1;

    // 2. 逆序遍历整个数组，从最大有效下标位置开始，到 0 结束
    for (int i = 10 - 1; i >= 0; i--) 
    {
        // 找到目标元素，index 存储对应下标位置，并且 break 终止循环
        if (num == arr[i])
        {
            index = i;
            break;
        }
    }

    // 根据 index 的数据存储情况，判断目标数据是否找到
    if (index > -1) 
    {
        printf("指定元素在数组中最后一次出现的下标位置: %d\n", index);
    }
    else
    {
        printf("目标元素未找到!\n");
    }

    return 0;
}

5.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, 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;
        }        
    }

    // 以上操作结束，可以 100% 确定 index 存储的下标位置就是整个数组中
    // 最大值对应的下标位置。【找极值】
    printf("最大值对应的下标位置: %d\n", index);

    return 0;
}

5.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;
}

5.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

#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, 7, 9, 2, 4, 6, 8, 10};

    print_int_array(arr, 10);
    printf("--------------------------------------------------------\n");
    // 直接利用循环对数组中的元素进行逆序操作
    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]);
    }
}

5.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}

【隐含一定的条件约束】
	对用户提供的下标数据进行合法性判断
*/

#include <stdio.h>
// C 语言标准库头文件
#include <stdlib.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, 7, 9, 2, 4, 6, 8, 10};
    // 用户指定替换的下标位置
    int index = 5;
    // 用户替换使用的数据
    int num = 20;

    print_int_array(arr, 10);
    printf("-------------------------------------------------------\n");

    // 1. 【重点】用户指定下标合法性判断
    if (index > 10 - 1 || index < 0)
    {
        printf("用户提供的下标数据非法!\n");
        // EXIT_FAILURE 退出状态，表示程序以运行失败状态退出
        return EXIT_FAILURE;
    }

    // 2. 首先取值被替换下标位置的元素数据情况
    int temp = arr[index];

    // 3. 使用新数据直接替换原本的数据内容
    arr[index] = num;

    print_int_array(arr, 10);
    printf("被替换的数据为: %d\n", temp);

    return 0;
}

5.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}
*/

#include <stdio.h>

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;

    print_int_array(arr, 10);
    printf("-------------------------------------------------------\n");

    // 1. 直接利用循环遍历整个数组，找出目标 old_num 元素，
    // 直接替换为 new_num
    for (int i = 0; i < 10; i++)
    {
        // 下标为 i 的元素数据和 old_num 一致
        if (old_num == arr[i])
        {
            // 数组中下标为 i 的元素赋值为 new_num
            arr[i] = new_num;
        }
    }
    print_int_array(arr, 10);

    return 0;
}

5.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;
}

2.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;
}

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 占位表示空
*/

/*
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;
}

2.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}
*/

#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;
}

2.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;
}

2.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;
}

6. 作业

• 冒泡排序
• 选择排序
• 快速排序【重难点】
• 二分法查询