C语言程序设计（八） 数组
第八章 数组
//L8-1
#include <stdio.h>
int main()
{
int score1, score2, score3, score4, score5;
int totalScore;
printf("Input the scores of ten students:\n");
scanf("%d", &score1);
scanf("%d", &score2);
scanf("%d", &score3);
scanf("%d", &score4);
scanf("%d", &score5);
totalScore = score1 + score2 + score3 +score4 + score5;
printf("The average score is %f\n", totalScore/5.0);
return 0;
}
//运行结果
Input the scores of ten students:
90
95
91
86
79
The average score is 88.200000
数组：解决需要对相同类型的批量数据进行处理的问题
数组是一组具有相同类型的变量的集合
- 数组名
- 数组元素：构成数组的每个数据项
- 数组的下标
- 数组的基类型：即数组中元素的类型
- 数组的维数：下标的个数
C语言中数组的下标都是从0开始的
//L8-1
#include <stdio.h>
int main()
{
int score[5];
int totalScore = 0;
int i;
printf("Input the scores of ten students:\n");
for (i=0; i<5; i++)
{
scanf("%d", &score[i]);
totalScore = totalScore + score[i];
}
printf("The average score is %f\n", totalScore/5.0);
return 0;
}
引用数组元素时下标可以是整型变量
但在定义数组时不能使用变量来定义数组的大小
数组一旦定义，就不能再改变它的大小
定义但未初始化的数组元素的值仍然是随机数
当数组被声明为静态存储类型或外部存储类型时，在不显式给出初值的情况下，数组元素将在程序编译阶段自动初始化为0
//L8-2
#include <stdio.h>
#define MONTHS 12
int main()
{
int days[MONTHS] = {31,28,31,30,31,30,31,31,30,31,30,31};
int month;
do{
printf("Input a month:");
scanf("%d", &month);
}while(month < 1 || month > 12); /* 处理不合法数据的输入 */
printf("The number of days is %d\n", days[month-1]);
return 0;
}
//运行结果
Input a month:3
The number of days is 31
在使用数组编写程序时要格外小心，要确保自己元素的正确引用，以免因下标越界而造成对其他存储单元中数据的破坏
//L8-3
#include <stdio.h>
int main()
{
int a = 1, c = 2, b[5] = {0}, i;
printf("%p, %p, %p\n", b, &c, &a);/* 打印数组b、变量c和a的首地址 */
for (i=0; i<=8; i++) /* 让下标值越界访问数组的元素 */
{
b[i] = i;
printf("%d ", b[i]);
}
printf("\nc=%d, a=%d, i=%d\n", c, a, i);
return 0;
}
//运行结果
0060FEF0, 0060FF04, 0060FF08
0 1 2 3 4 5 6 7 8
c=5, a=6, i=9
变量a和c的值因数组越界而被悄悄地破坏了！
二维数组的定义
类型 数组名[第一维长度][第二维长度]
n维数组用n个下标来确定各元素在数组中的位置
C语言中不带下标的数组名具有特殊的含义，它代表数组的首地址，因此不能整体引用一个数组
依次输入数组中的全部元素的值，必须使用循环语句
二维数组既可以按元素初始化，也可以按行初始化
二维数组第二维的长度声明永远都不能省略
//L8-4
#include <stdio.h>
#define MONTHS 12
int main()
{
int days[2][MONTHS] = {{31,28,31,30,31,30,31,31,30,31,30,31}, {31,29,31,30,31,30,31,31,30,31,30,31}};
int year, month;
do{
printf("Input year,month:");
scanf("%d,%d", &year, &month);
} while(month < 1 || month > 12); /* 处理不合法数据的输入 */
if (((year%4 == 0) && (year%100 != 0)) || (year%400 == 0))/*闰年*/
printf("The number of days is %d\n", days[1][month-1]);
else /*非闰年*/
printf("The number of days is %d\n", days[0][month-1]);
return 0;
}
//运行结果
Input year,month:2019,6
The number of days is 30
//L8-5
#include <stdio.h>
#define N 40
int Average(int score[], int n); /* Average()函数原型 */
void ReadScore(int score[], int n); /* ReadScore()函数原型 */
int main()
{
int score[N], aver, n;
printf("Input n:");
scanf("%d", &n);
ReadScore(score, n); /* 数组名作为函数实参调用函数ReadScore() */
aver = Average(score, n); /* 数组名作为函数实参调用函数Average() */
printf("Average score is %d\n",aver);
return 0;
}
/* 函数功能： 计算n个学生成绩的平均分 */
int Average(int score[], int n) /* Average()函数定义 */
{
int i, sum = 0;
for (i=0; i<n; i++)
{
sum += score[i];
}
return sum / n;
}
/* 函数功能：输入n个学生的某门课成绩 */
void ReadScore(int score[], int n) /* ReadScore()函数定义 */
{
int i;
printf("Input score:");
for (i=0; i<n; i++)
{
scanf("%d", &score[i]);
}
}
若要把一个数组传递给一个函数，只要使用不带方括号的数组名作为函数实参调用函数即可
由于数组名代表数组第一个元素的地址，因此用数组名作函数实参实际上是将数组的首地址传给被调函数
数组作函数形参时，数组的长度可以不出现在数组名后面的方括号中，通常用另一个整型形参来指定数组的长度
//L8-6
#include <stdio.h>
#define N 40
int Average(int score[], int n); /* Average()函数原型 */
int ReadScore(int score[]); /* ReadScore()函数原型 */
int main()
{
int score[N], aver, n;
n = ReadScore(score); /*调用函数ReadScore()输入成绩，返回学生人数*/
printf("Total students are %d\n",n);
aver = Average(score, n); /*调用函数Average()计算平均分，返回平均分*/
printf("Average score is %d\n",aver);
return 0;
}
/* 函数功能：计算n个学生成绩的平均分 */
int Average(int score[], int n) /* Average()函数定义 */
{
int i, sum = 0;
for (i=0; i<n; i++)
{
sum += score[i];
}
return n>0 ? sum/n : -1;
}
/* 函数功能：输入学生某门课成绩，当输入成绩为负值时，结束输入，返回学生人数 */
int ReadScore(int score[]) /* ReadScore()函数定义 */
{
int i = -1; /*i初始化为-1，循环体内增1后可保证数组下标从0开始*/
do{
i++;
printf("Input score:");
scanf("%d", &score[i]);
}while (score[i] >= 0); /* 输入负值时结束输入 */
//以负值作为输入结束的标记值，这种循环控制也称为标记控制的循环
return i; /* 返回学生人数 */
}
//运行结果
Input score:89
Input score:94
Input score:20
Input score:0
Input score:-1
Total students are 4
Average score is 50
//L8-7
#include <stdio.h>
#define N 40
int ReadScore(int score[]); /* ReadScore()函数原型 */
int FindMax(int score[], int n); /* FindMax()函数原型 */
int main()
{
int score[N], max, n;
n = ReadScore(score); /*调用函数ReadScore()输入成绩，返回学生人数*/
printf("Total students are %d\n",n);
max = FindMax(score, n); /*调用函数FindMax()计算最高分，返回最高分*/
printf("The highest score is %d\n",max);
return 0;
}
/* 函数功能：输入学生某门课的成绩，当输入负值时，结束输入，返回学生人数 */
int ReadScore(int score[]) /* ReadScore()函数定义 */
{
int i = -1; /*i初始化为-1，循环体内增1后可保证数组下标从0开始*/
do{
i++;
printf("Input score:");
scanf("%d", &score[i]);
} while (score[i] >= 0); /* 输入负值时结束成绩输入 */
return i; /* 返回学生人数 */
}
/* 函数功能：计算最高分 */
int FindMax(int score[], int n)/* FindMax()函数定义 */
{
int max, i;
max = score[0]; /* 假设score[0]值为当前最大值 */
for (i=1; i<n; i++)
{
if (score[i] > max) /* 若score[i]值较大 */
{
max = score[i]; /* 则用score[i]值替换当前最大值 */
}
}
return max; /* 返回最高分 */
}
//运行结果
Input score:89
Input score:94
Input score:20
Input score:0
Input score:-1
Total students are 4
The highest score is 94
排序：
排序是把一系列无序的数据按照特定的顺序重新排列为有序序列的过程
成熟的排序算法：交换法、选择法、插入排序、冒泡法、快速排序算法
//L8-8(交换法)
#include <stdio.h>
#define N 40
int ReadScore(int score[]); /* ReadScore()函数原型 */
void DataSort(int score[], int n); /* DataSort()原函数型 */
void PrintScore(int score[], int n); /* PrintScore()函数原型 */
int main()
{
int score[N], n;
n = ReadScore(score); /*调用函数ReadScore()输入成绩，返回学生人数*/
printf("Total students are %d\n", n);
DataSort(score, n); /* 调用函数DataSort()进行成绩排序 */
printf("Sorted scores:");
PrintScore(score, n); /* 调用函数Printscore()输出成绩排序结果 */
return 0;
}
/* 函数功能：输入学生某门课的成绩，当输入负值时，结束输入，返回学生人数 */
int ReadScore(int score[]) /* ReadScore()函数定义 */
{
int i = -1; /* i初始化为-1，可保证循环体内i增1后数组下标从0开始 */
do{
i++;
printf("Input score:");
scanf("%d", &score[i]);
}while (score[i] >= 0); /* 输入负值时结束成绩输入 */
return i; /* 返回学生人数 */
}
/* 函数功能：按交换法将数组score的元素值元素按从高到低排序 */
void DataSort(int score[], int n) /* DataSort()函数定义 */
{
int i, j, temp;
for (i=0; i<n-1; i++)
{
for (j=i+1; j<n; j++)
{
if (score[j] > score[i]) /* 按数组score的元素值从高到低排序 */
{
temp = score[j];
score[j] = score[i];
score[i] = temp;
}
}
}
}
/* 函数功能： 打印学生成绩 */
void PrintScore(int score[], int n) /* PrintScore()函数定义 */
{
int i;
for (i=0; i<n; i++)
{
printf("%4d", score[i]);
}
printf("\n");
}
//L8-8(选择法)
#include <stdio.h>
#define N 40
int ReadScore(int score[]); /* ReadScore()函数原型 */
void DataSort(int score[], int n); /* DataSort()原函数型 */
void PrintScore(int score[], int n); /* PrintScore()函数原型 */
int main()
{
int score[N], n;
n = ReadScore(score); /*调用函数ReadScore()输入成绩，返回学生人数*/
printf("Total students are %d\n", n);
DataSort(score, n); /* 调用函数DataSort()进行成绩排序 */
printf("Sorted scores:");
PrintScore(score, n); /* 调用函数Printscore()输出成绩排序结果 */
return 0;
}
/* 函数功能：输入学生某门课的成绩，当输入负值时，结束输入，返回学生人数 */
int ReadScore(int score[]) /* ReadScore()函数定义 */
{
int i = -1; /* i初始化为-1，可保证循环体内i增1后数组下标从0开始 */
do{
i++;
printf("Input score:");
scanf("%d", &score[i]);
}while (score[i] >= 0); /* 输入负值时结束成绩输入 */
return i; /* 返回学生人数 */
}
/* 函数功能：按选择法将数组score的元素值元素按从高到低排序 */
void DataSort(int score[], int n)
{
int i, j, k, temp;
for (i=0; i<n-1; i++)
{
k = i;
for (j=i+1; j<n; j++)
{
if (score[j] > score[k]) /* 按数组score的元素值从高到低排序 */
{
k = j; /* 记录最大数下标位置 */
}
}
if (k != i) /* 若最大数所在的下标位置不在下标位置i */
{
temp = score[k];//每一轮比较中最多只用一次两数交换操作，减少了交换次数
score[k] = score[i];
score[i] = temp;
}
}
} /* 函数功能： 打印学生成绩 */
void PrintScore(int score[], int n) /* PrintScore()函数定义 */
{
int i;
for (i=0; i<n; i++)
{
printf("%4d", score[i]);
}
printf("\n");
}
//L8-9
#include <stdio.h>
#define N 40
int ReadScore(int score[], long num[]); /*ReadScore()函数原型*/
void DataSort(int score[], long num[], int n); /*DataSort()原函数型*/
void PrintScore(int score[], long num[], int n);/*PrintScore()函数原型*/
int main()
{
int score[N], n;
long num[N];
n = ReadScore(score, num); /* 输入成绩和学号，返回学生总数 */
printf("Total students are %d\n", n);
DataSort(score, num, n); /* 成绩排序 */
printf("Sorted scores:\n");
PrintScore(score, num, n); /* 输出成绩排序结果 */
return 0;
}
/* 函数功能：输入学生的学号及其某门课成绩，当输入负值时，结束输入，返回学生人数 */
int ReadScore(int score[], long num[]) /* ReadScore()函数定义 */
{
int i = -1; /* i初始化为-1，可保证循环体内i增1后数组下标从0开始 */
do{
i++;
printf("Input student's ID and score:");
scanf("%ld%d", &num[i], &score[i]); /* 以长整型格式输入学号 */
}while (num[i] >0 && score[i] >= 0); /* 输入负值时结束成绩输入 */
return i; /* 返回学生总数 */
}
/* 函数功能：按选择法将数组score的元素值按从高到低排序 */
void DataSort(int score[], long num[], int n) /*DataSort()函数定义*/
{
int i, j, k, temp1;
long temp2;
for (i=0; i<n-1; i++)
{
k = i;
for (j=i+1; j<n; j++)
{
if (score[j] > score[k]) /* 按数组score的元素值从高到低排序 */
{
k = j; /* 记录最大数下标位置 */
}
}
if (k != i) /* 若最大数不在下标位置i */
{
/* 交换成绩 */
temp1 = score[k]; score[k] = score[i]; score[i] = temp1;
/* 交换学号 */
temp2 = num[k]; num[k] = num[i]; num[i] = temp2;
}
}
}
/* 函数功能：打印学生学号和成绩 */
void PrintScore(int score[], long num[], int n) /*PrintScore()函数定义*/
{
int i;
for (i=0; i<n; i++)
{
printf("%10ld%4d\n", num[i], score[i]); /* 以长整型格式打印学号 */
}
}
对信息进行排序时，通常只使用信息的一个子项作为键值，由键值决定信息的全部子项的排列顺序
在此将学生成绩作为键值，在比较中只使用成绩值，而在实际实施交换操作时才移动整个数据结构(学号和成绩)
查找：
在数组中搜索一个特定元素的处理过程，称为查找。
线性查找(顺序查找)、折半查找
//L8-10(线性查找)
#include <stdio.h>
#define N 40
int ReadScore(int score[], long num[]); /*ReadScore()函数原型*/
int LinSearch(long num[], long x, int n); /* LinSearch()原函数型*/
int main()
{
int score[N], n, pos;
long num[N], x;
n = ReadScore(score, num); /* 输入成绩和学号，返回学生总数 */
printf("Total students are %d\n", n);
printf("Input the searching ID:");
scanf("%ld", &x); /* 以长整型格式从键盘输入待查找的学号x */
pos = LinSearch(num, x, n); /* 查找学号为num的学生 */
if (pos != -1) /* 若找到，则打印其分数 */
{
printf("score = %d\n", score[pos]);
}
else /* 若未找到，则打印"未找到"提示信息*/
{
printf("Not found!\n");
}
return 0;
}
/* 函数功能：输入学生的学号及其某门课成绩，当输入负值时，结束输入，返回学生人数 */
int ReadScore(int score[], long num[]) /* ReadScore()函数定义 */
{
int i = -1; /*i初始化为-1，循环体内增1后可保证数组下标从0开始*/
do{
i++;
printf("Input student's ID and score:");
scanf("%ld%d", &num[i], &score[i]);
} while (num[i] >0 && score[i] >= 0); /* 输入负值时结束成绩输入 */
return i; /* 返回学生总数 */
}
/*按线性查找法查找值为x的数组元素，若找到则返回x在数组中的下标位置，否则返回-1*/
int LinSearch(long num[], long x, int n) /* LinSearch()函数定义 */
{
int i;
for (i=0; i<n; i++)
{
if (num[i] == x) return i; /* 若找到则返回x在数组中的下标 */
}
return (-1); /* 若循环结束仍未找到，则返回-1 */
}
//L8-11(折半查找)
#include <stdio.h>
#define N 40
int ReadScore(int score[], long num[]); /*ReadScore()函数原型*/
int BinSearch(long num[], long x, int n); /*BinSearch()原函数型*/
int main()
{
int score[N], n, pos;
long num[N], x;
n = ReadScore(score, num); /* 输入成绩和学号，返回学生总数 */
printf("Total students are %d\n", n);
printf("Input the searching ID:");
scanf("%ld", &x); /* 以长整型格式从键盘输入待查找的学号x */
pos = BinSearch(num, x, n); /* 查找学号为num的学生 */
if (pos != -1) /* 若找到，则打印其分数 */
{
printf("score = %d\n", score[pos]);
}
else /* 若未找到，则打印"未找到"提示信息*/
{
printf("Not found!\n");
}
return 0;
}
/* 函数功能：输入学生的学号及其某门课成绩，当输入负值时，结束输入，返回学生人数 */
int ReadScore(int score[], long num[]) /* ReadScore()函数定义 */
{
int i = -1; /*i初始化为-1，循环体内增1后可保证数组下标从0开始*/
do{
i++;
printf("Input student's ID and score:");
scanf("%ld%d", &num[i], &score[i]);
} while (num[i] >0 && score[i] >= 0); /* 输入负值时结束成绩输入 */
return i; /* 返回学生总数 */
}
/*按折半查找法查找值为x的数组元素，若找到则返回x在数组中的下标位置，否则返回-1*/
int BinSearch(long num[], long x, int n) /*BinSearch()函数定义*/
{
int low=0, high=n-1, mid; /* 区间左端点low置为0，右端点high置为n-1 */
int pos = -1; /* 若循环结束仍未找到，则返回pos的初始值-1 */
int find = 0; /* 置找到标志变量flag为假 */
while (!find && low <= high)/*若未找到且左端点小于等于右端点，则继续查找*/
{
mid = (high + low) / 2; /* 取数据区间的中点 */
//整数除法，如果high + low为奇数则舍去0.5
if (x > num[mid])
{
low = mid + 1; /* 若x>num[mid]，则修改区间的左端点 */
}
else if (x < num[mid])
{
high = mid - 1; /* 若x<num[mid]，则修改区间的右端点 */
}
else
{
pos = mid; /* 若找到，则置下标值为mid */
find = 1; /* 置找到标志变量flag为真 */
}
}
return pos;
}
当待查找信息有序排列时，折半查找法比顺序查找法的平均查找速度要快得多。折半查找也称为对分搜索
折半查找法的基本思想为：
首先选取位于数组中间的元素，将其与查找键进行比较
如果它们的值相等，则查找键被找到，返回数组中间元素的下标
否则，将查找的区间缩小为原来区间的一半，即在一半的数组元素中继续查找
用数组名作为函数参数时，需要注意以下3点：
- 声明一维形参数组时，在方括号内可以给出数组的长度(声明为固定长度数组)，也可以不给出数组的长度(声明为可变长度数组)，这时一般用一个整型参数给出数组的长度
- 用数组名作为函数实参时，形参数组和实参数组既可同名，也可不同名
- 在被调函数中改变形参数组元素值时，实参数组元素值也会随之变化
//L8-12
#include <stdio.h>
#define STUD_N 40 /* 最多学生人数 */
#define COURSE_N 3 /* 考试科目数 */
void ReadScore(int score[][COURSE_N], long num[], int n);
void AverforStud(int score[][COURSE_N], int sum[], float aver[], int n);
void AverforCourse(int score[][COURSE_N], int sum[], float aver[], int n);
void Print(int score[][COURSE_N], long num[], int sumS[], float averS[],
int sumC[],float averC[], int n);
int main()
{
int score[STUD_N][COURSE_N], sumS[STUD_N], sumC[STUD_N], n;
long num[STUD_N];
float averS[STUD_N], averC[STUD_N];
printf("Input the total number of the students(n<=40):");
scanf("%d", &n); /* 输入参加考试的学生人数 */
ReadScore(score, num, n); /* 读入n个学生的学号和成绩 */
AverforStud(score, sumS, averS, n); /* 计算每个学生的总分平均分 */
AverforCourse(score, sumC, averC, n); /* 计算每门课程的总分平均分 */
Print(score, num, sumS, averS, sumC, averC, n); /* 输出学生成绩 */
return 0;
}
/* 函数功能：输入n个学生的学号及其三门课的成绩 */
void ReadScore(int score[][COURSE_N], long num[], int n)
{
int i, j;
printf("Input student's ID and score as: MT EN PH:\n");
for (i=0; i<n; i++) /* 对所有学生进行循环 */
{
scanf("%ld", &num[i]); /* 以长整型格式输入每个学生的学号 */
for (j=0; j<COURSE_N; j++) /* 对所有课程进行循环 */
{
scanf("%d", &score[i][j]); /* 输入每个学生的各门课成绩 */
}
}
}
/* 函数功能： 计算每个学生的总分和平均分 */
void AverforStud(int score[][COURSE_N], int sum[], float aver[], int n)
{
int i, j;
for (i=0; i<n; i++)
{
sum[i] = 0;
for (j=0; j<COURSE_N; j++) /* 对所有课程进行循环 */
{
sum[i] = sum[i] + score[i][j]; /* 计算第i个学生的总分 */
}
aver[i] = (float)sum[i] / COURSE_N;/* 计算第i个学生的平均分 */
}
}
/* 函数功能：计算每门课程的总分和平均分 */
void AverforCourse(int score[][COURSE_N], int sum[], float aver[], int n)
{
int i, j;
for (j=0; j<COURSE_N; j++)
{
sum[j] = 0;
for (i=0; i<n; i++) /* 对所有学生进行循环 */
{
sum[j] = sum[j] + score[i][j]; /* 计算第j门课程的总分 */
}
aver[j] = (float)sum[j] / n; /* 计算第j门课程的平均分 */
}
}
/*函数功能：打印每个学生的学号、各门课成绩、总分和平均分，以及每门课的总分和平均分*/
void Print(int score[][COURSE_N], long num[], int sumS[], float averS[],
int sumC[], float averC[], int n)
{
int i, j;
printf("Student's ID\t MT \t EN \t PH \t SUM \t AVER\n");
for (i=0; i<n; i++)
{
printf("%12ld\t",num[i]); /* 以长整型格式打印学生的学号 */
for (j=0; j<COURSE_N; j++)
{
printf("%4d\t", score[i][j]); /* 打印学生的每门课成绩 */
}
printf("%4d\t%5.1f\n", sumS[i], averS[i]);/*打印学生的总分平均分*/
}
printf("SumofCourse \t");
for (j=0; j<COURSE_N; j++) /* 打印每门课的总分 */
{
printf("%4d\t", sumC[j]);
}
printf("\nAverofCourse\t");
for (j=0; j<COURSE_N; j++) /* 打印每门课的平均分 */
{
printf("%4.1f\t", averC[j]);
}
printf("\n");
}
//运行结果
Input the total number of the students(n<=40):4
Input student's ID and score as: MT EN PH:
120310122 97 87 92
120310123 92 91 90
120310124 90 81 82
120310125 73 65 80
Student's ID MT EN PH SUM AVER
120310122 97 87 92 276 92.0
120310123 92 91 90 273 91.0
120310124 90 81 82 253 84.3
120310125 73 65 80 218 72.7
SumofCourse 352 324 344
AverofCourse 88.0 81.0 86.0
- 函数ReadScore()用于从键盘输入学生的学号及其三门课的成绩
- 函数AverforStu()用于计算每个学生的总分和平均分
- 函数AverforCourse()用于计算每门课程的总分和平均分
- 函数Print()用于打印每个学生的学号、各门课成绩、总分和平均分，以及每门课程的总分和平均分
C语言程序设计（八） 数组的更多相关文章
- C语言程序设计之 数组2020-10-28
C语言程序设计之 数组2020-10-28 整理: 第一题:求最小数与第一个数交换 [问题描述] 输入一个正整数n (1<n<=100),再输入n个整数,将最小值与第一个数交换,然后输 ...
- C语言程序设计第八次作业
一.学习内容 本次课学习了一维数组的基本知识,需要大家对如下知识点进行总结: 1. 数组的定义,数组元素的引用,数组的初始化和赋值. 2. 明确以下问题:能否给数组名赋值?为什 ...
- C语言程序设计（十一） 指针和数组
第十一章 指针和数组 一旦给出数组的定义,编译系统就会为其在内存中分配固定的存储单元,相应的,数组的首地址也就确定了 C语言中的数组名有特殊的含义,它代表存放数组元素的连续存储空间的首地址 //L11 ...
- 《C语言程序设计（第四版）》阅读心得（一）
本篇开始写我个人觉得谭浩强老师的<C语言程序设计(第四版)>中之前没有认识到,或者忘了的知识.因为本科学过,所以有些简单的东西就没有放进来了,所以可能并不是太全面. 第一章程序设计与语言 ...
- 2019年春季学期《C语言程序设计II》课程总结
2019年春季学期<C语言程序设计II>课程总结 1.课程情况 教学内容 课堂小结 作业安排 优秀作业 备注 1.开学谈心 2.测验数据类型.运算符与表达式的自学情况,并讲解测验题目3.第 ...
- GO语言总结(3)——数组和切片
上篇博文简单介绍了一下Go语言的基本类型——GO语言总结(2)——基本类型,本篇博文开始介绍Go语言的数组和切片. 一.数组 与其他大多数语言类似,Go语言的数组也是一个元素类型相同的定长的序列. ( ...
- C语言程序设计入门学习五步曲（转发）
笔者在从事教学的过程中,听到同学抱怨最多的一句话是:老师,上课我也能听懂,书上的例题也能看明白,可是到自己动手做编程时,却不知道如何下手.发生这种现象的原因有三个: 一.所谓的看懂听明白,只是很肤浅的 ...
- 《VB语言程序设计（第3版）》总结
我之前因学习昆仑通态的组态软件MCGS,用并学习过VB,还买了一本书<VB语言程序设计(第3版)>.现在在某公司实习,最近接触老的项目,又要用到VB.我就又把那本书大体看了一遍,并对其进行 ...
- Swift语言指南(八)--语言基础之元组
原文:Swift语言指南(八)--语言基础之元组 元组 元组(Tuples)将多个值组合为一个复合值.元组内的值可以是任何类型,各个元素不需要为相同类型(各个元素之间类型独立,互不干扰--Joe.Hu ...
- C语言程序设计课程设计自查表格
课程设计自查表格 序号 项目 完成与否(完成打勾) 1 格式是否符合标准(缩进是否规范) 2 是否模块化设计(使用函数分解系统功能) 3 函数名否易懂(不得使用f1(int a1,int a2)这样的 ...
随机推荐
- django框架进阶-ModelForm组件-长期维护
############################################################ """ 通常在Django项目中,我们编写的大部 ...
- jQuery选择器的效率问题
jQuery提供了功能强大,并兼容多种css版本的选择器,不过发现很多同学在使用选择器时并未注重效率的问题. a) 尽量使用Id选择器,jQuery选择器使用的API都是基于getElementByI ...
- PHP--修改数据库表前缀
<?php // error_reporting(0); //设置好相关信息 $dbserver='localhost';//连接的服务器一般为localhost $dbname='jfpay' ...
- 转载——Python Selenium 常用方法总结
selenium Python 总结一些工作中可能会经常使用到的API. 1.获取当前页面的Url 方法:current_url 实例:driver.current_url 2.获取元素坐标 方法:l ...
- Trailing Zeroes (III) LightOJ - 1138 二分+找规律
Time Limit: 2 second(s) Memory Limit: 32 MB You task is to find minimal natural number N, so that N! ...
- hibernate lazy属性参数说明
lazy,延迟加载 Lazy的有效期:只有在session打开的时候才有效:session关闭后lazy就没效了. lazy策略可以用在: * <class>标签上:可以取值true/fa ...
- Spring学习笔记（七）模拟实际开发过程的调用过程XML版-Setter方式注入
模拟实际开发过程的调用过程XML版-Setter方式注入 源码获取github [TOC] 1.项目结构 2.jar包跟上个一样 3.重写set方法 UserServiceImpl.java 1234 ...
- c#版阿里云oss上传——基于layui、pupload的oss 后端web端直传的vue组件
废话前言 去年,做项目用到oss上传,度娘上逛了一圈写了个前后端代码结合的c#版oss上传. 今年又要用到oss上传时发现很难复用,复用改动的范围太大,显然这个轮子不合格.于是想了下,花了一天的时间( ...
- 6487. 【GDOI2020模拟02.29】列强争霸war
题目描述 区间绝对众数 即出现次数>len/2下取整的数 对于区间[L,R]扫一遍,维护一个数x和出现次数s 当前数=x则s+1,否则s-1,若s已为0则把x设为当前数 若区间内存在绝对众数,那 ...
- swoole(1)使用docker安装swoole环境
1.下载镜像 pull php 镜像 docker pull php:7.3-alpine3.8 创建容器 docker run -it --name test php:7.3-alpine3.8 s ...