数组和结构体训练

一、结构体以及注意点

结构体的定义：

结构体的初始化和赋值（使用）：

注意点：

1.结构体类型明不能与其他变量相同，但结构体成员名可以 

2.定义关键字struct以及分号；

3.初始化方式和数组类似，但相同类型结构体可以相互赋值

二、倍数标记法找质数

一维数组的一个应用，这里不再过多描述其他找质数方法。

本方法的原理即动态规划即利用数组的存储特性利用之前的计算结果，来简化后续的计算。

输入：固定范围自然数（这里取1-100）

输出：范围内所有的质数

代码：（伪代码先不写了，用注释代替）

#include                                //输入输出头文件
#include                                 //数学运算头文件（开根号）
void main() {
    const int n = 100;                           //定义规模（常量）
    int i,j,notsushu[n + 1] = { 0 };             //定义数组和变量
    for (i = 2; i <=  sqrt(float(n)); ++i) {     //从1-sqrt（n）找到倍数,如果找1-n,则大于sqrt（n）的倍数会重复使用，因为大于sqrt（n）取倍数的时候不会取到另一个大于sqrt(n)的数
        if (notsushu[i] == 0) {
            for (j = 2*i; j <= n; j += i) {      

                notsushu[j] = 1;                 //做标记
            }
        }
    }
    for (i = 2; i <= n; i++) {
        if (notsushu[i] == 0) {
            printf("%d\n",i);
        }
    }
}

三、冒泡排序

在冒泡排序中需要用到数组来存储数据，作为数据的载体。

冒泡排序原理：

冒泡排序的原理为多次排序，每一次排序将每组最大的数排到一端（最后），然后对未排序的子序列迭代排序。每次将未排序序列的最值冒出来，即为冒泡。

直到所有的未排序子序列的最大值都到同侧，此时序列有序。

输入：一组无序的整数

输出：对应的有序数列

代码：

#include

void main() {
    //const int n = 6;
    int a[] = { 2,5,1,6,4,3 };               //输入
    int    n = sizeof(a)/sizeof(a[0]);          //计算数组长度
    int i, j,temp=0;                         //配置计数器和寄存器
    for (i = 1; i <= n-1; i++) {             //总次
        for (j = 0; j < n - i; j++) {        //单次冒泡
            if (a[j] > a[j + 1]) {           //替换操作
                temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
    }
    for (i = 0; i <= n - 1; i++) {           //输出
        printf("%d\n", a[i]);
    }
}
四、折半查找（二分法）

在原有的排序的基础上，加上了二分查找算法。算法实现就是设立三个标尺（三个变量），通过二分法指导标尺的移动。

输入：一组数和一个查找数

输出：查找数在数组中的大小位次

代码：

#include
#include

int main() {

    int a[] = { 8,7,6,5,4,3,2,1,11,13,14,14,15},x=13;               //输入
    int    n = sizeof(a) / sizeof(a[0]);          //计算数组长度
    int i, j, temp = 0;                         //配置计数器和寄存器
    for (i = 1; i <= n - 1; i++) {             //总次
        for (j = 0; j < n - i; j++) {        //单次冒泡
            if (a[j] > a[j + 1]) {           //替换操作
                temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
    }
    int low = 1, high = n, mid;             
    mid = (low + high) / 2;
    while (low <= high) {                   //二分法操作
        if (x>a[mid-1]) {                      //x在大半段
            low = mid;
        }
        else if (x < a[mid-1]) {            //x在小半段
            high = mid;
        }
        else {                                     //找到位置了！
            printf("%d\n",mid);              //输出
            return 0;
        }
        mid = (low+high) / 2;
    }

}

五、求斐波那契数（典型动态规划）

动态规划需要用到前步骤的结果，需要数组进行存储，没什么可以多说的。

输入：斐波那契数的位数

输出：斐波那契数列

代码：

#include
//include<>

int main() {
    const int n = 10;                             //输入
    int f[n] = {0};                               //定义数组
    int i=0;                                      //定义计数器
    f[0] = 1;                                     //初始化斐波那契
    f[1] = 1;
    for (i = 2; i < n ; i++) {                    //算斐波那契数列
        f[i] = f[i - 1] + f[i - 2];
    }

    for (i = 0; i < n; i++) {                     //输出
        printf("%d\n",f[i]);
    }
    return 1;
}

六、时钟

1.自组时钟

2.显示当前时钟

七、数据分析

 这里时间关系还没学完，记得回来复习