一维整型数组

一维整形数组

数组的特点：数组就是可以连续存储多个同一类型数据的结构就叫数组。

1 格式

数据类型 数组名[长度]; ---->(长度就是一个数组中存多少个数据)

以整形数组为例: int arr[3]; --->定义了一个能够存储3个整形数据的数组arr

注意：

数组名是一个标识符,要满足标识符的命名规范:

1、由数字、字母和下划线构成

2、不能以数字开头

3、严格区分大小写

4、不能和C语言中的32个关键字重复

2 数组中元素的初始化和赋值

数组中元素的初始化要放到{}中

完全初始化:数组中能存多少个元素就给多少个元素初始化

不完全初始化:给数组中的部分元素初始化

不给定长度的初始化:定义数组时不写长度，根据初始化列表来给数组分配空间

#include <stdio.h>
int main(int argc, const char *argv[])
{
    int arr[3]={1,2,3};
    //定义了一个能存3个整形变量的数组arr，并完全初始化
    /***数组的不完全初始化***/
    int arr1[4]={34,12};  
    //定义了一个数组arr1，不完全初始化，未初始化的部分默认为0
    printf("arr1[2]=%d\n",arr1[2]);
    printf("arr1[3]=%d\n",arr1[3]);
    //给arr1数组中下标为2和下标为3的元素赋值
    //直接访问元素下标进行赋值
 arr1[2]=89;
 arr1[3]=100;
    printf("赋值后\n");
    printf("arr1[2]=%d\n",arr1[2]);
    printf("arr1[3]=%d\n",arr1[3]);

    /*****定义数组不给长度的初始化*****/
    int arr2[]={12,8,5,4,3}; 
    //定义了数组arr2没有给定长度，会根据初始化列表给数组分配空间
    printf("sizeof(arr2)=%ld\n",sizeof(arr2));

    return 0;
}

3 数组中元素的访问

访问数组中元素： 数组名[下标]; 数组中元素的下标从0开始,数组中元素的最大下标=长度-1;

验证地址连续：

 %p用来输出地址

4 数组的大小

(定义时给了数组多大的空间，数组后面就有多大的空间)

数组大小=数据类型*元素个数

数组中元素个数=数组大小/数据类型大小

#include <stdio.h>
int main(int argc, const char *argv[])
{
    int arr[]={};
    printf("%ld\n",sizeof(arr));
    int arr1[4];
    printf("%ld\n",sizeof(arr1));
    printf("arr1中有%d个元素\n",sizeof(arr1)/sizeof(arr1[0]));
    return 0;
}

5 数组的逆置

如果有一个数组a[5]={1,2,3,4,5},现在我想想将其变为数组a[5]={5,4,3,2,1}

这就是数组的逆置，将a[0]与a[4]，a[1]与a[3]逆置

#include <stdio.h>
int main(int argc, const char *argv[])
{
    int arr[5]={12,90,31,87,56};

    //实现数组的逆置
    int i,temp;
    int len = sizeof(arr)/sizeof(arr[0]);
    for(i=0;i<len/2;i++)  //需要元素交换的次数
    {
        //交换第i个和第len-1-i个元素
        temp = arr[i];
        arr[i] = arr[len-1-i];
        arr[len-1-i] = temp;
    }

    //逆置后的输出
    for(i=0;i<len;i++)
    {
        printf("%d\n",arr[i]);
    }
    return 0;
}

6 冒泡排序

每次相邻的两个元素两两比较，将待排序序列中的最大值/最小值，放到序列中最末尾的位置，直到所有元素都排序成功，冒泡排序结束。

#include <stdio.h>
int main(int argc, const char *argv[])
{
    int arr[5]={13,9,21,1,19};
    int i,j,temp;
    int len = sizeof(arr)/sizeof(arr[0]);
    //进行冒泡排序

    //外层控制排序次数
    for(i=1;i<len;i++)
    {
        //内层循环控制元素间比较
        for(j=0;j<len-i;j++)
        {
            //升序
            if(arr[j]>arr[j+1])
            {
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }

    for(i=0;i<len;i++)
    {
        printf("%d\n",arr[i]);
    }
    return 0;
}

7 选择排序

执行逻辑：

每次选出待排序序列中的最大/最小值和第一个元素互换。

#include <stdio.h>
int main(int argc, const char *argv[])
{
    int arr[5]={13,9,21,1,19};
    int i,j,temp;
    int len = sizeof(arr)/sizeof(arr[0]);
    int min_index;  //最小值的下标
    //选择排序
    for(i=1;i<len;i++)
    {
        //每次假定最小值的下标是待排序序列中的第一个元素
        min_index = i-1;
        //内层循环找最小值的下标
        for(j=i;j<len;j++)
        {
            //假定的最小值比待排序序列中的元素还要大
            if(arr[min_index]>arr[j])
            {
                min_index = j;   //更新最小值的下标
            }
        }
        //内层循环结束找到待排序序列中的最小值
        //和第一个元素交换
        if(min_index!=i-1)  //如果最小值下标不是第一个元素下标,可以不判断
        {
            temp = arr[min_index];
            arr[min_index] = arr[i-1];
            arr[i-1] = temp;
        }
  }
}