C/C++实践笔记 016数组细枝末节与排序基础

一、数组细枝末节

1.switch表达式必须是整数，常量表达式，不能带变量
其值必须是整数，或字符，或枚举
switch必须是块语句
实数不能用==或!=来判断，会不精确

2.同一类型多个元素的组合——数组
数组是可以在内存中连续存储多个元素的结构

int a[5]; //a是数组名，代表数组的首地址

&a[i],a+i等价关系，代表数组第i个元素的地址
*根据地址取出内容

a[i],*(&a[i]),*(a+i)等价关系

3.编译的时候，确定大小叫静态分配

GCC可以动态分配数组，动态分配，运行的时候
VC必须静态分配

4.C/C++数组必须初始化，不然会有垃圾数据

数组初始化语法：
int a[10]={0};
int a[]={1,2,3,4,5,6,7,8,9,0}; //明确初始化大小，可以省略下标

数组不可以越界

int a[10]={1,2,3,4};//默认没有初始化值，都会填充0

5.数组名是一个常量，不可以修改，不可以赋值
数组的元素可以修改
a是数组名，a[i]是数组元素
C语言数组不可以批量操作，可以针对某一个元素批量操作

数组不可批量输出，字符串例外str[5]

6.数组越界问题
越界不一定出错，不越界一定不会发生内存访问冲突

7.数组实战
一维数组逆序输出

取出数组最大值

8.二维数组

 

int a[5][4]={0};
int a[5][4]={{1,2,3,4},{1,2}};  //二维数组的初始化方式，未赋值的为0
//5个一维数组，数组有四个元素

行坐标可以省略，纵坐标不可以

int a[3][4];

for(int i=0;i<12;i++)
{
    a[i/4][i%4]=i;

}

//线性方式给二维数组初始化
//0  1  2  3
//4  5  6  7
//8  9  10 11

 

 

 

二、排序基础

1、选择法：

void main()
{
    int a[20] = { 1,2,3,4,8,9 };
    int  max = a[0];
    for (int i = 1; i < 20; i++)
    {
        if (a[i] > max)  //选择法找数组最大值
        {
            max = a[i];  
        }
    }
    printf("\nmax=%d", max);
    system("pause");
}

 

选择排序法（时空复杂度：浪费时间最长，不管有序没序都会比一遍
O（1）空间 ，时间O（n^2）: 100+99+98+97+……+1 n(n-1)/2 ）：

#include<stdlib.h>
#include<stdio.h>
#define N 20
void main()
{
    int a[N] = { 6,1,2,3,4 ,9,5,1,4};
    int kmax = 0; //记录最值的下标
    for (int i = 0; i < N - 1; i++)
    {
        kmax = i;
        for (int j = i + 1; j < N; j++)
        {
            if (a[j] > a[kmax])
            {
                kmax = j;  //循环，记录最大的下标
            }
        }
        if (kmax!=i)
        {
            int temp = a[kmax];
            a[kmax] = a[i];
            a[i] = temp;

        }
    }
    for (int i = 0; i < N; i++)
    {
        printf("\n%d", a[i]);
    }
    system("pause");
}

 

2、冒泡排序法
（1）找最大值

#include<stdlib.h>
#include<stdio.h>
void main()
{
    int a[10] = { 6,1,2,3,4,9,5,1,4,2};
    for (int i = 0; i < 10 - 1; i++)
    {
        if (a[i] > a[i + 1]) //对比
        {
            int temp = a[i]; //交换
            a[i] = a[i + 1];
            a[i+1] = temp;
        }
        
    }
    printf("%d", a[9]);  //找出最大值
    getchar();
}

 

(2)冒泡排序

#include<stdlib.h>
#include<stdio.h>
#define N 10
void main()
{
    int a[N] = { 6,1,2,3,4,9,5,1,4,2};
    for (int i = 0; i < N - 1; i++)  //每循环一次，就有一个最大值沉底
    { 
        for (int j = 0; j < N - 1 - i; j++)  //沉底的次数，决定冒泡冒到哪里
        {
            if (a[j] > a[j + 1])
            {
                int temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
        
        
    }
    for (int i = 0; i < N; i++)
    {
        printf("%d", a[i]);
    }
    
    getchar();
}

 

3、斐波那契的数组法

#include<stdlib.h>
#include<stdio.h>
void main()
{
    int a[40];
    a[0] = 1;
    a[1] = 1;
    for (int i = 2; i < 40; i++)
    {
        a[i] = a[i - 1] + a[i - 2];  //借助数组循环快过递归
    }
    printf("%d", a[39]);

    getchar();
    
}