数据结构-数组(详细讲解)

文章目录

数组

数组的概述

  • 概述:数组是一种线性数据结构,它由一组按顺序排列的元素组成。每个元素都有一个唯一的索引,用于访问和操作该元素。数组可以包含任意类型的数据,如整数、浮点数、字符串等
  • 注意:数组是只能存储一种数据类型,且数组一旦创建,大小就固定的容器。
  • 优缺点:
    • 数组的优点,快速访问和搜索速度,因为元素的位置是固定的,可以通过索引直接访问
    • 数组的缺点,插入和删除操作可能会导致大量元素的移动,从而影响性能,并且数组的大小一旦创建就是固定的
  • 种类:
    • 一维数组
    • 二维数组(二维数组其实就是多维数组,像一个表格一样)
    • 多维数组

数组的图示

一维数组
二维数组
  • 二维数组可以看成一个表格,下边就是一个4行3列的二维数组
  • 二维数组也可以看成一维数组中嵌套一维数组的样式,下边图也是一个 4行3列的二维数组

数组的定义

一维数组的定义
  • 格式

    c 复制代码
    // 格式一
    数据类型 数组名[长度];
    // 格式二
    数据类型 数组名[长度] = {值1,值2...值n};
    // 格式三
    数据类型 数组名[] = {值1,值2...值n};
  • 示例

    c 复制代码
    // 定义一个长度为 5 的整型数组
    int a[5];
    // 定义一个长度为 5 的整型数组,并初始化(初始化就是赋值的意思)
    int b[5] = {1,2,3,4,5};
    // 定义一个整型数组,并初始化,可以看到方括号中并无长度,是因为初始化列表自动推断数组的大小
    int c[] = {1,2,3,4,5};
二维数组的定义
  • 格式

    c 复制代码
    // 格式一
    数据类型 数组名[行数][列数];
    // 格式二
    数据类型 数组名[行数][列数] = {{值1,值2...值n},{值1,值2...值n},...,{值1,值2...值n}};
    // 格式三
    数据类型 数组名[][列数] = {{值1,值2...值n},{值1,值2...值n},...,{值1,值2...值n}};
  • 示例

    c 复制代码
    // 定义一个3行4列的整型二维数组
    int a[3][4];
    // 定义一个3行4列的整型二维数组,并初始化
    int b[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
    // 初始化列表自动推断数组是多少行
    int c[][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};

数组的取值赋值

一维数组
c 复制代码
#include <stdio.h>					// 打印需要靠这个 标准输入输出库

int main() {
    // 定义一个一维数组
    int arr[] = {1, 2, 3, 4, 5};

    // 访问数组中的元素
    printf("%d\n", arr[0]);  // 输出:1
    printf("%d\n", arr[2]);  // 输出:3

    // 修改数组中的元素
    arr[3] = 6;
    for (int i = 0; i < 5; i++) {
        printf("%d ", arr[i]);  // 输出:1 2 3 6 5
    }

    // 获取数组的长度
    int length = sizeof(arr) / sizeof(arr[0]);
    printf("\n%d\n", length);  // 输出:5

    return 0;
}
二维数组
c 复制代码
#include <stdio.h>

int main() {
    // 定义一个二维数组
    int arr2d[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

    // 访问二维数组中的元素
    printf("%d\n", arr2d[0][0]);  // 输出:1
    printf("%d\n", arr2d[1][2]);  // 输出:6

    // 修改二维数组中的元素
    arr2d[2][1] = 10;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", arr2d[i][j]);  // 输出:1 2 3 4 5 6 7 10 9
        }
    }

    // 获取二维数组的行数和列数
    int rows = sizeof(arr2d) / sizeof(arr2d[0]);
    int cols = sizeof(arr2d[0]) / sizeof(arr2d[0][0]);
    printf("\n%d %d\n", rows, cols);  // 输出:3 3

    return 0;
}

数组的操作

一维数组的操作
索引实现
c 复制代码
#include <stdio.h>

// 使用索引进行操作
void arrayOperationsWithIndex(int arr[], int size) {
    // 插入操作,insertIndex 是要插入的位置,insertValue 是要插入的值
    int insertIndex = 2;
    int insertValue = 10;
    // 将插入位置之后的元素依次向后移动
    for (int i = size - 1; i >= insertIndex; i--) {
        arr[i + 1] = arr[i];
    }
    // 插入元素
    arr[insertIndex] = insertValue;
    // 改变数组长度
    size++;

    // 删除操作
    int deleteIndex = 3;
    // 将 deleteIndex 之后的元素依次前移,覆盖
    for (int i = deleteIndex; i < size - 1; i++) {
        arr[i] = arr[i + 1];
    }
    size--;

    // 修改操作
    int modifyIndex = 1;
    int newValue = 20;
    arr[modifyIndex] = newValue;

    // 查找操作
    int target = 20;
    int found = 0;
    for (int i = 0; i < size; i++) {
        if (arr[i] == target) {
            printf("元素 %d 找到了,索引为 %d\n", target, i);
            found = 1;
            break;
        }
    }
    if (!found) {
        printf("未找到元素 %d\n", target);
    }
}
int main() {
    int arr1[10] = {1, 2, 3, 4, 5};
    int size1 = 5;

    // 使用索引进行操作
    arrayOperationsWithIndex(arr1, size1);

    return 0;
}
指针实现
c 复制代码
#include <stdio.h>
// 使用指针进行操作
void arrayOperationsWithPointer(int *arr, int *size) {
    // 插入操作
    int insertIndex = 2;
    int insertValue = 10;
    for (int i = *size - 1; i >= insertIndex; i--) {
        *(arr + i + 1) = *(arr + i);
    }
    *(arr + insertIndex) = insertValue;
    (*size)++;

    // 删除操作
    int deleteIndex = 3;
    for (int i = deleteIndex; i < *size - 1; i++) {
        *(arr + i) = *(arr + i + 1);
    }
    (*size)--;

    // 修改操作
    int modifyIndex = 1;
    int newValue = 20;
    *(arr + modifyIndex) = newValue;

    // 查找操作
    int target = 20;
    int found = 0;
    for (int i = 0; i < *size; i++) {
        if (*(arr + i) == target) {
            printf("元素 %d 找到了,索引为 %d\n", target, i);
            found = 1;
            break;
        }
    }
    if (!found) {
        printf("未找到元素 %d\n", target);
    }
}
int main() {

    int arr2[10] = {1, 2, 3, 4, 5};
    int size2 = 5;

    // 使用指针进行操作
    arrayOperationsWithPointer(arr2, &size2);

    return 0;
}
二位数组的操作
矩阵转三元组
c 复制代码
#include <stdio.h>

// 定义矩阵的行数和列数
#define ROWS 3
#define COLS 3

// 定义矩阵转换为三元组的结构体
typedef struct Triple {
    int row;				// 行
    int col;				// 列
    int value;				// 值
}Triple;

/* 
	定义矩阵转换为三元组的函数
	参数:
		matrix[ROWS][COLS]		矩阵,用二维数组实现
		rows					矩阵行数
		cols					矩阵列数
		triple[]				三元组数组
*/
int convertToTriple(int matrix[ROWS][COLS], int rows, int cols, Triple triple[]) {
    int count = 0;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (matrix[i][j] != 0) {
                /*
                	下边四行代码释义:
                		1、将不等于0元素的行值存到三元组中
                		2、将不等于0元素的列值存到三元组中
                		3、将不等于0元素的值存到三元组中
                		4、行数加1
                */
                triple[count].row = i;
                triple[count].col = j;
                triple[count].value = matrix[i][j];
                count++;
            }
        }
    }
    return count;
}

int main() {
    // 定义一个矩阵
    int matrix[ROWS][COLS] = {
        {1, 0, 0},
        {0, 2, 0},
        {0, 0, 3}
    };

    // 打印原始矩阵
    printf("原始矩阵:\n");
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }

    // 将矩阵转换为三元组
    Triple triple[ROWS * COLS];
    int count = convertToTriple(matrix, ROWS, COLS, triple);

    // 打印三元组
    printf("转换后的三元组:\n");
    for (int i = 0; i < count; i++) {
        printf("(%d, %d, %d)\n", triple[i].row, triple[i].col, triple[i].value);
    }

    return 0;
}

三元组,就是将矩阵压缩的一种形式,将非零元素值的位置和值存到三元组数组中,零元素值不存储

矩阵的乘法
c 复制代码
#include <stdio.h>

#define ROWS1 2
#define COLS1 3
#define ROWS2 3
#define COLS2 2

/*
	矩阵乘法函数
	参数:
		mat1[ROWS1][COLS1]					矩阵1
		mat2[ROWS2][COLS2]					矩阵2
		result[ROWS1][COLS2]				结果矩阵
*/ 
void matrixMultiply(int mat1[ROWS1][COLS1], int mat2[ROWS2][COLS2], int result[ROWS1][COLS2]) {
 	// 遍历矩阵1的行
    for (int i = 0; i < ROWS1; i++) {
        // 遍历矩阵2的列
        for (int j = 0; j < COLS2; j++) {
            // 首先将这个位置初始化为 0
            result[i][j] = 0;
            // k 作为矩阵1 的列,矩阵2 的行
            for (int k = 0; k < COLS1; k++) {
                // 矩阵1的i行上的每个值 乘以 矩阵2 j列上的每个值相加之和,就是 i,j 位置的乘积
                result[i][j] += mat1[i][k] * mat2[k][j];
            }
        }
    }
}

int main() {
    int mat1[ROWS1][COLS1] = {{1, 2, 3}, {4, 5, 6}};
    int mat2[ROWS2][COLS2] = {{7, 8}, {9, 10}, {11, 12}};
    int result[ROWS1][COLS2];

    // 打印原始矩阵1
    printf("矩阵1:\n");
    for (int i = 0; i < ROWS1; i++) {
        for (int j = 0; j < COLS1; j++) {
            printf("%d ", mat1[i][j]);
        }
        printf("\n");
    }

    // 打印原始矩阵2
    printf("矩阵2:\n");
    for (int i = 0; i < ROWS2; i++) {
        for (int j = 0; j < COLS2; j++) {
            printf("%d ", mat2[i][j]);
        }
        printf("\n");
    }

    // 对矩阵进行相乘
    matrixMultiply(mat1, mat2, result);

    // 打印相乘后的结果矩阵
    printf("相乘后的结果矩阵:\n");
    for (int i = 0; i < ROWS1; i++) {
        for (int j = 0; j < COLS2; j++) {
            printf("%d ", result[i][j]);
        }
        printf("\n");
    }

    return 0;
}

注意:矩阵的乘法,需要知道,矩阵 A~mxn~ * B~nxt~ = C~mxt~ ,矩阵B的行数得等于矩阵A的列数,这样才能相乘

相关推荐
daiyang123...1 小时前
测试岗位应该学什么
数据结构
kitesxian1 小时前
Leetcode448. 找到所有数组中消失的数字(HOT100)+Leetcode139. 单词拆分(HOT100)
数据结构·算法·leetcode
薯条不要番茄酱3 小时前
数据结构-8.Java. 七大排序算法(中篇)
java·开发语言·数据结构·后端·算法·排序算法·intellij-idea
盼海5 小时前
排序算法(五)--归并排序
数据结构·算法·排序算法
搬砖的小码农_Sky11 小时前
C语言:数组
c语言·数据结构
先鱼鲨生13 小时前
数据结构——栈、队列
数据结构
一念之坤13 小时前
零基础学Python之数据结构 -- 01篇
数据结构·python
IT 青年13 小时前
数据结构 (1)基本概念和术语
数据结构·算法
熬夜学编程的小王13 小时前
【初阶数据结构篇】双向链表的实现(赋源码)
数据结构·c++·链表·双向链表
liujjjiyun14 小时前
小R的随机播放顺序
数据结构·c++·算法