[数据结构与算法]数组知识大总结

一维数组的创建和初始化

数组的创建

数组是一组相同类型元素的集合

tyoe_ty arr_name [const_n]

数组元素类型 常量表达式，指定数组大小

注意：

C99中引入了变长数组（长度可变）的概念，允许数组大小用变量来制定，如果编译器不支持C99的变长数组那就不能使用

VS2019不支持变长数组

数组的初始化

创建的同时并赋值

int main()
{
    int arr1[10] = {1,2,3,4};//不完全初始化//10
    int arr2[] = {1,2,3,4};//4
    //char ch1[] = {'a','b'};
    //char ch2[] = {'a',98};
    return 0;
}

注意：变长数组是不能初始化的

在静态区创建的变量默认初始化值为0（全局变量，静态变量）

在栈区创建的变量若不初始化是随机值（局部变量，形式参数）

一维数组的使用

[ ]下标引用操作符，下标从0开始

arr[4] arr，4是[ ]的两个操作数

int main()
{   
    //计算数组元素个数的写法
    int sz =sizeof(arr)/sizeof(arr[0]);
    int arr[100] = {1,2,3,4,5,6};//创建数组时不能使用变量
    //写代码赋值1~100
    int i = 0
    //赋值
    for (i= 0; i < ; i++)
    {
        a[i] = i + 1;
    }
    //打印
    for (i = 0; i < sz; i++)
    {
        printf("%d",arr[i]);//可以使用变量
    }
}

一维数组在内存中的存储

int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    //打印数组的每个元素地址
    int i = 0;
    int sz = sizeof(arr)/sizeof(arr[0]);
    for (i=0;i<sz;i++)
    {
        printf("&arr[%d]=%p\n",i,&arr[i]);
    }
    return 0;
}

一维数组在内存中是连续存放的（差4字节)→可以用下标和指针访问

随着数组下标的增长，地址是由低到高变化的

数组名是数组首元素的地址

两个例外：

1. sizeof（数组名），数组名表示整个数组，计算整个数组的大小
2. &数组名，数组名表示整个数组，取出的是整个数组的地址

%p--打印地址

char* p：跳过一个字符

二维数组的创建和初始化

二维数组的创建

int main()
{
	int arr[3][5];
	     //三行五列

	return 0；
}

二维数组的初始化

可以省略行，但不能省略列

 //int arr[3][5] = { 1,2,3,4,5,6 };//不完全初始化
    // int arr[][5] = { 1,2,3,4,5,6 };
	     
	int arr[][5] = {{1,2},{3,4},{5,6}};

二维数组的访问

int main()
{
           
	//int arr[3][5] = { 1,2,3,4,5,6 };//不完全初始化
    // int arr[][5] = { 1,2,3,4,5,6 };
	     
	int arr[][5] = {{1,2},{3,4},{5,6}};
 int i = 0;
 for (i=0;i<3;i+=)
 //i<sizeof(arr)/sizeof(arr[0])
 {
     int j=0;
     for (j=0;j<5;j++)
     //j<sizeof(arr[0])/sizeof(arr[0][0])
     {
         printf("%d ",arr[i][j]);//下标访问操作符
     }
     printf("\n");
 }
	return 0；
}

二维数组的内存存储

int main()
{     	     
	int arr[3][5] = {{1,2},{3,4},{5,6}};
    int i = 0;
    for (i=0;i<3;i+=)
 {
     int j=0;
     for (j=0;j<5;j++)
     {
         printf("&arr[i][j] = %p\n ",i,j,&arr[i][j]);
     }
 }
	return 0；
}

二维数组在内存中也是连续存放的

数组越界

下标必须在0~n-1当中不要超越数组访问

程序员需要自行检查（编译器一般不报错）

二维一维都存在越界问题

数组作为函数参数

冒泡排序函数

数组中两个相邻元素进行比较，如果不满足顺序就交换

n个元素进行n-1趟冒泡排序

void bubble_sort(int arr[],int sz)//指针
// void bubble_sort(int* arr，int sz)

{
    //趟数
    
    int i = 0;
    for (i = 0; i < sz-1; i++)
    {
        int flag = 0;
        //每一趟冒泡过程
        int j = 0;
        for (j = 0; j <sz-1-i ; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                flag=0;
                //交换
                int tmp = arr[j];
                arr[j] = arr[j +1];
                arr[j + 1] = tmp;
            }
        }
    }
}


int main()
{
    int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
    //冒泡排序函数
    //arr表示首元素地址
    int sz = sizeof(arr) / sizeof(arr[0]);

    bubble_sort(arr,sz);
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}