#4数组#

1.一维数组的创建和初始化

(1)创建

type_t   arr_name   [const_n];

//type_t 是指数组的元素类型

//const_n 是一个常量表达式，用来指定数组的大小

int arr[10]={1,2,3};//不完全初始化
char arr2[5]={'a',98}; //方块里面为常量 不能为变量
char arr3[5]="ab";//float double类型也可以
char arr4[]="abcdef";//还有\0 字符串默认有\0 单独几个字符不打\0就没有 

(2)初始化

int arr1[10] = {1,2,3};
int arr2[] = {1,2,3,4};
int arr3[5] = {1，2，3，4，5}；
char arr4[3] = {'a',98, 'c'};
char arr5[] = {'a','b','c'};
char arr6[] = "abcdef";

(3)使用

#include <stdio.h>
int main()
{
 	int arr[10] = {0};//数组的不完全初始化
    //计算数组的元素个数
    int sz = sizeof(arr)/sizeof(arr[0]);//整个数组字节数除以一个元素的字节数 
	//对数组内容赋值 数组是使用下标来访问的 下标从0开始
	int i = 0;//当下标 
	for(i=0; i<10; i++)
	{
		arr[i] = i;
	} 
	//输出数组的内容
	for(i=0; i<10; ++i)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

数组是使用下标来访问的，下标是从0开始。

(4)存储

#include <stdio.h>
int main()
{
     int arr[10] = {0};
    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;
}

数组在内存中是连续存放的。

2.二维数组的创建和初始化

(1)创建

int arr[3][4];

char arr[3][5];

double arr[2][4];

(2)初始化

int arr[3][4]={{1,2,3},{4,5}};//3行4列 1 2 3第一行 4 5第二行整体大括号 
char ch[5][6];//访问下标都是从0开始 
int arr[3][4]={{1,2,3,4},{5,6,7,8}};//列不能省 行可以省略 

(3)使用

#include <stdio.h>
int main()
{
    int arr[3][4]={{1,2,3},{4,5}};
    int i=0;
    for(i=0;i<3;i++)
    {
    	int j=0;
    	for(j=0;j<4;j++)
    	{
    		printf("%d ",arr[i][j]);//for循环嵌套i j走过整个数组 
		}
		printf("\n");//一行打印完换行 
	}
	//1 2 3 0
    //4 5 0 0
    //0 0 0 0
    //0 0 0 0
    return 0; 
}

(4)存储

#include <stdio.h>
int main()
{
	int arr[3][4];
	int i = 0;
	for(i=0; i<3; i++)
	{
		int j = 0;
		for(j=0; j<4; j++)
		{
			printf("&arr[%d][%d] = %p\n", i, j,&arr[i][j]);
		}
	}
	return 0;
}

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

3.数组越界

数组的下标是有范围限制的。

数组的下规定是从0开始的，如果数组有n个元素，最后一个元素的下标就是n-1。

所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。

4.数组作为函数参数

冒泡排序

#include <stdio.h>
void bubble_sort(int arr[])
{
	int sz = sizeof(arr)/sizeof(arr[0]);
    int i = 0;
	for(i=0; i<sz-1; i++)
	{
        int j = 0;
        for(j=0; j<sz-i-1; j++)
        {
            if(arr[j] > arr[j+1])
            {
                int tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }
        }
    }
}
int main()
{
    int arr[] = {3,1,7,5,8,9,0,2,4,6};
    bubble_sort(arr);
    for(i=0; i<sizeof(arr)/sizeof(arr[0]); i++)
    {
        printf("%d ", arr[i]);
    }
    return 0;
}

这个程序在bubble_sort内部sz的大小为1 这是为什么呢?

这就涉及到数组名了

数组名是数组首元素的地址。（有两个例外）

1. sizeof(数组名)，计算整个数组的大小，sizeof内部单独放一个数组名，数组名表示整个数 组。

2. &数组名，取出的是数组的地址。&数组名，数组名表示整个数组。

除此1,2两种情况之外，所有的数组名都表示数组首元素的地址。

因此当把数组名传给函数时 只会传首元素的地址 导致sz=1 从而无法实现冒泡排序

正确设计如下:

#include<stdio.h>
//双循环 外循环控制排序次数 内循环控制交换次数 
void bubble_sort(int arr[],int sz)
{
	//确定冒泡排序的趟数 n-1次
	int i=0; 
	for(i=0;i<sz-1;i++)
	{
		int flag=1;//假设这一趟要排序的数据已经有序
		//每一趟冒泡排序
		int j=0;
		for(j=0;j<sz-1-i;j++)//每有一个数有序 交换次数就少一次 
		{
			if(arr[j]>arr[j+1])//如果有序 进入循环后会直接跳出内循环进入下面if语句 最后直接跳出外循环 
			{
				int tmp=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=tmp;
				flag=0;//本趟排序的数据其实不完全有序 
			}
		} 
		if(flag==1)//简化 防止排好序后接着输出循环里的代码 
		{
			break;//跳出循环 
		}
	}
}
int main()
{
	int i=0;
	int arr[]={9,8,7,6,5,4,3,2,1,0};
	//对arr排序 排成升序 冒泡排序 相邻两个元素比较 交换 最后为升序 
	int sz=sizeof(arr)/sizeof(arr[0]);
	bubble_sort(arr,sz);//9次冒泡排序 10个元素 实际上传递过去的数组arr首元素的地址 &arr[0] 
	for(i=0;i<sz;i++)
	{
		printf("%d ",arr[i]);
	}
	return 0; //1sizeof (数组名)-数组名表示整个数组 整个数组大萧 
}             //2&数组名 数组名代表整个数组 &数组名 取出的是整个数组的地址
 //3&arr不要认为是第一个元素的地址 打印结果一样 但含义不同 如果加1 加4*元素个数 

sz也作为一个参数传过去

#4数组#完