目录
前言
为了在程序设计中处理方便,通常把具有相同类型的若干变量按有序的形式组织起来,这种集合称为数组。按元素的类型不同,数组又可分为数值数组、字符数组、指针数组、结构数组等各种类别。
一、一维数组
定义
类型说明符 数组名[常量表达式];
//类型说明符是任一种基本数据类型或构造数据类型
//数组名是用户定义的数组标识符
//方括号种的常量表达式表示数据元素的个数,也成为数组的长度
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);
二、二维数组
在实际问题中有很多量是二维的或多维的,因此C语言允许构造多维数组。二维数组可以看成是由一维数组作为数组元素的一维数组。
定义
类型说明符 数组名[常量表达式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;
}