C语言：基础——数组

_DonQuijote

已于 2023-10-10 19:54:47 修改

阅读量69

点赞数

分类专栏： C语言文章标签： c语言

于 2023-10-08 19:47:13 首次发布

本文链接：https://blog.csdn.net/my_yi/article/details/133674602

版权

C语言专栏收录该内容

11 篇文章 2 订阅

订阅专栏

前言

为了在程序设计中处理方便，通常把具有相同类型的若干变量按有序的形式组织起来，这种集合称为数组。按元素的类型不同，数组又可分为数值数组、字符数组、指针数组、结构数组等各种类别。

一、一维数组

定义

类型说明符 数组名[常量表达式];
//类型说明符是任一种基本数据类型或构造数据类型
//数组名是用户定义的数组标识符
//方括号种的常量表达式表示数据元素的个数，也成为数组的长度

PS：考虑到程序的移植性，不要使用变长数组，即不要在方括号中用变量来表示元素的个数，但是可以是符号常量或常量表达式。

初始化

方式一：在定义数组的同时进行初始化

类型说明符 数组名[常量表达式] = {值, 值,……, 值};

方式二：对某些符合运算规律的数组元素进行初始化

数组名[下标] = 表达式;

方式三：通过循环和用户输入给数组进行动态初始化

for(……)
{
    scanf("占位符", 元素地址);
}

PS：

1、可以只给部分元素赋初值，当{}中值的个数少于元素个数时，只给前面部分元素赋值。如：

int a[10] = {0, 1, 2, 3, 4}; //表示只给a[0]~a[4]5个元素赋值，而后5个元素自动赋值0

2、只能给元素逐个赋值，不能给数组整体赋值。如：

//正确写法
int a[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
//错误写法
int a[10] = 1;

3、如给全部元素赋值，则在数组定义中可以不指定数组的长度。如：

int a[] = {1, 2, 3, 4, 5};

4、数组赋值时不要越界操作，否则会引发不可预知的严重后果。如：

int a[5] = {5, 4, 3, 2, 1, 0}; //数组超限

引用

数组名[下标]

PS：

1、下标只能为整型常量或整型表达式。

2、在C语言中，只能逐个使用下标引用数组元素，不能一次引用整个数组。如：

//正确形式
for (i = 0; i < 10; i++) printf("%d", a[i]);
//错误形式
printf("%d", a);

二、二维数组

在实际问题中有很多量是二维的或多维的，因此Ｃ语言允许构造多维数组。二维数组可以看成是由一维数组作为数组元素的一维数组。

定义

类型说明符 数组名[常量表达式1][常量表达式2];

初始化

方式一：按元素存储顺序初始化

int a[2][3] = {1, 2, 3, 4, 5, 6}; //全部初始化，第一行元素{1，2，3}，第二行元素{4，5，6}
int a[2][3] = {1, 2, 3}; //部分初始化，第一行元素{1，2，3}，第二行元素{0，0，0}

方式二：按行初始化

int a[2][3] = {{1, 2, 3}, {4, 5, 6}}; //全部初始化，第一行元素{1，2，3}，第二行元素{4，5，6}
int a[2][3] = {{1}, {5, 6}}; //部分初始化，第一行元素{1，0，0}，第二行元素{5，6，0}

方式三：省略行的初始化（列不能省略）

int a[][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}};
int b[][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
int c[][3] = {{1, 2}, {3}};

引用

数组名[行的下标][列的下标]

三、扩展

用数组实现冒泡排序算法

冒泡排序（bubble sort），是一种计算机科学领域的较简单的排序算法，因越小的元素经由交换慢慢“浮”到数列顶端而得名。以下是一个简单的C语言冒泡排序程序：

#include <stdio.h>

//冒泡排序函数 
void bubbleSort(int arr[], int n)
{
    for (int i = 0; i < n - 1; i++)
        for (int j = 0; j < n - i - 1; j++)
        {
             //比较与下一个元素的大小   
            if (arr[j] > arr[j + 1])
            {
                // 交换arr[j]和arr[j+1]
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
}

int main()
{
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);
    
    bubbleSort(arr, n);
    
    printf("排序后的数组：");
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    
    return 0;
}

该程序首先定义了一个bubbleSort函数用于实现冒泡排序的逻辑。在main函数中，我们定义了一个待排序的数组arr，并计算出数组的长度n。然后调用bubbleSort函数对数组进行排序。最后，使用循环打印出排序后的数组。

用数组实现选择排序算法

选择排序（selection sort）每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列后面，直到全部待排序的数据元素排完。以下是一个简单的C语言选择排序程序：

#include <stdio.h>

// 选择排序函数
void selectionSort(int arr[], int n)
{
    int i, j, minIndex, temp;
    for (i = 0; i < n - 1; i++)
    {
        minIndex = i; // 假设当前元素是最小值
        for (j = i + 1; j < n; j++)
        {
            // 如果找到比当前最小值更小的元素，更新最小值索引
            if (arr[j] < arr[minIndex])
                minIndex = j;
        }
        // 交换当前元素与最小值元素的位置
        temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

int main()
{
    int arr[] = {64, 25, 12, 22, 11};
    int n = sizeof(arr) / sizeof(arr[0]);

    selectionSort(arr, n);

    printf("排序后的数组：");
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);

    return 0;
}

这个程序中，selectionSort函数使用选择排序算法对数组进行排序。main函数中定义了一个整数数组，并调用selectionSort函数对数组进行排序，最后打印排序后的数组。

用数组实现栈

原理

栈是一种后进先出（Last-In/First-Out）的数据结构。

栈是一种特殊的线性表，是一种只允许在一端进行插入或删除操作的线性表。允许进行插入、删除操作的一端成为栈顶，另一端称为栈底。

栈顶的当前位置是动态的，当栈中没有数据元素时，称为空栈。栈的插入操作称为进栈（入栈或压栈），栈的删除操作称为退栈（出栈或弹出）。

栈分为向上增长（压栈时地址增加，即递增堆栈）和向下增长（压栈时地址减小，即递减堆栈），Linux中采用向下增长。

利用数组按下标进行顺序存储、删除、插入元素的特点，这样可使用数组来实现栈的功能。

实现

定义对栈进行操作的头文件stack.h

#define MAX_SIZE 30

/*判断栈是否为满*/
int is_full();
/*判断栈是否为空*/
int is_empty();
/*入栈*/
void push(int element);
/*出栈*/
int popup();
/*获得栈顶元素*/
int top();

定义实现栈操作函数功能的源文件stack.c

#include "stack.h"

int stack[MAX_SIZE]; //全局变量，当作栈使用的数组
int position; //栈顶位置变量

/*判断栈是否为满*/
int is_full()
{
    return position >= MAX_SIZE;
}
/*判断栈是否为空*/
int is_empty()
{
    return position == 0;
}
/*入栈*/
void push(int element)
{
    if(is_full())
        return;
    stack[position] = element;
    position++;
}
/*出栈*/
int popup()
{
    if(is_empty())
        return 0;
    position--;
    int element = stack[position];
    return element;
}
/*获得栈顶元素*/
int top()
{
    if(is_empty())
        return 0;
    int element = stack[position - 1];
    return element;
}

调用栈操作函数的入口源文件test.c

#include <stdio.h>
#include "stack.h"

int main()
{
    push(10);
    push(11);
    push(12);
    push(13);
    printf("popup is:%d\n", popup());
    printf("popup is:%d\n", popup());
    printf("top is:%d\n", top());

    push(14);
    push(15);
    printf("popup is:%d\n", popup());
    printf("popup is:%d\n", popup());
    printf("popup is:%d\n", popup());
    printf("popup is:%d\n", popup());

    return 0;
}

用数组实现队列

原理

队列（queue）是一种先进先出（First-In-First-Out）的数据结构。

队列只允许在后端（rear）/尾部进行插入操作，在前端（front）/头部进行删除操作。

利用数组按下标进行顺序存储、删除、插入元素的特点，可在数组的末尾插入元素（代表队列的后端），在数组的首部删除元素（代表队列的前端），这样可使用数组来实现队列的功能。

实现

定义对队列进行操作的头文件queue.h

#define MAX_SIZE 30

/*判断队列是否为满*/
int is_full();
/*判断队列是否为空*/
int is_empty();
/*入列*/
void enqueue(int element);
/*出列*/
int dequeue();

定义实现队列操作函数功能的源文件queue.c

#include "queue.h"

int queue[MAX_SIZE]; //全局变量，当作队列使用的数组
int position; //队首位置变量
void remove(unsigned int index); //删除函数声明

/*判断队列是否为满*/
int is_full()
{
    return position >= MAX_SIZE;
}
/*判断队列是否为空*/
int is_empty()
{
    return position == 0;
}
/*入列*/
void enqueue(int element)
{
    if(is_full())
        return;
    queue[position] = element;
    position++;
}
/*出列*/
int dequeue()
{
    if(is_empty())
        return 0;
    int element = queue[0];
    remove(0); //删除头部元素
    position--;
    return element;
}
/*删除*/
void remove(unsigned int index)
{
    int i;
    for(i = index; i < position - 1; i++)
        queue[i] = queue[i+1];
}

调用队列操作函数的入口源文件test.c

#include <stdio.h>
#include "queue.h"
 
int main(void)
{
    enqueue(1);
    enqueue(2);
    enqueue(3);
 
    printf("dequeue is:%d\n", dequeue());
    printf("dequeue is:%d\n", dequeue());
    printf("dequeue is:%d\n", dequeue());
    printf("dequeue is:%d\n", dequeue());
 
    return 0;
}