C试题
第9题:编写函数fun,它的功能是:根据公式 P = ( m!)/(n!(m-n)!) 求P的值,结果由函数值带回。m与n为两个正整数且要求m>n。例如: m=12,n=8时,运行结果为495.000000.
ChatGPT回答如下:
主要考察了以下几个知识点:
这道题考察了C语言的函数、循环、数据类型、运算符等知识点。回。
该程序的解题思路:
-
定义一个函数fun,参数为m和n,返回值为P。
-
在函数中,先判断m是否大于n,如果不是,则输出错误信息并返回0。
-
如果m大于等于n,则定义三个变量m_factorial、n_factorial和diff_factorial,分别表示m的阶乘、n的阶乘和(m-n)的阶乘。
-
使用循环计算m的阶乘,n的阶乘和(m-n)的阶乘。
-
根据P的公式计算P的值,并返回结果。
-
在主函数中调用fun函数,输入m和n的值,并输出P的值。
解法一:C语言代码:
#include <stdio.h>
double fun(int m, int n);
int main()
{
int m = 12, n = 8;
double p = fun(m, n);
printf("P = %lf\n", p);
return 0;
}
double fun(int m, int n)
{
int i;
double p = 1.0;
for (i = n + 1; i <= m; i++) {
p *= i;
}
for (i = 1; i <= m - n; i++) {
p /= i;
}
return p;
}
在这个程序中,我们先定义了一个函数fun来计算P的值,然后在主函数中调用该函数并输出结果。当m=12,n=8时,运行结果为495.000000,符合题目要求。
解法二:C语言代码:
#include <stdio.h>
double fun(int m, int n) {
if (m <= n) {
printf("Error: m should be greater than n.\n");
return 0;
}
double m_factorial = 1, n_factorial = 1, diff_factorial = 1;
for (int i = 1; i <= m; i++) {
m_factorial *= i;
if (i <= n) {
n_factorial *= i;
}
if (i <= m - n) {
diff_factorial *= i;
}
}
double P = m_factorial / (n_factorial * diff_factorial);
return P;
}
int main() {
int m = 12, n = 8;
double P = fun(m, n);
printf("P = %lf\n", P);
return 0;
}
运行结果为:
P = 495.000000
解法三:C语言代码:
#include <stdio.h>
double fun(int m, int n) {
int i;
double p = 1;
for (i = 1; i <= n; i++) {
p *= (double)(m - n + i) / i;
}
return p;
}
int main() {
int m = 12, n = 8;
double p = fun(m, n);
printf("%.6lf", p);
return 0;
}
这个通用写法使用了数学公式,直接计算出P的值。难点在于要注意数据类型转换,以及避免除以0的情况。另外,需要保证m>n。
解法四:C语言代码:指针写法
#include <stdio.h>
double fun(int m, int n) {
int i;
double p = 1;
double *temp = (double*)malloc(n * sizeof(double));
temp[0] = 1;
for (i = 1; i <= n; i++) {
temp[i] = temp[i - 1] * (double)(m - n + i) / i;
}
p = temp[n];
free(temp);
return p;
}
int main() {
int m = 12, n = 8;
double p = fun(m, n);
printf("%.6lf", p);
return 0;
}
这个指针写法使用了动态内存分配,将中间结果保存在一个数组中。难点在于需要注意内存的申请和释放,以及数组的下标从0开始。
解法五:C语言代码: 数组写法
#include <stdio.h>
double fun(int m, int n) {
int i;
double p = 1;
double temp[n + 1];
temp[0] = 1;
for (i = 1; i <= n; i++) {
temp[i] = temp[i - 1] * (double)(m - n + i) / i;
}
p = temp[n];
return p;
}
int main() {
int m = 12, n = 8;
double p = fun(m, n);
printf("%.6lf", p);
return 0;
}
这个数组写法和指针写法类似,只是没有使用动态内存分配,而是直接定义了一个数组。难点在于需要注意数组的大小,以及数组的下标从0开始。
解法六:C语言代码: 栈写法
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int m;
int n;
double p;
} Item;
typedef struct {
int top;
int size;
Item *data;
} Stack;
void init(Stack *s, int size) {
s->top = -1;
s->size = size;
s->data = (Item*)malloc(size * sizeof(Item));
}
void push(Stack *s, Item item) {
s->top++;
s->data[s->top] = item;
}
Item pop(Stack *s) {
Item item = s->data[s->top];
s->top--;
return item;
}
int is_empty(Stack *s) {
return s->top == -1;
}
double fun(int m, int n) {
Stack s;
init(&s, n + 1);
Item item;
item.m = m;
item.n = n;
item.p = 1;
push(&s, item);
while (!is_empty(&s)) {
item = pop(&s);
m = item.m;
n = item.n;
if (n == 0) {
item.p = 1;
} else if (n == 1) {
item.p = (double)m;
} else {
Item item1;
item1.m = m - 1;
item1.n = n - 1;
push(&s, item1);
Item item2;
item2.m = m - 1;
item2.n = n;
push(&s, item2);
}
item.p *= (double)m / (m - n + 1);
if (n > 1) {
push(&s, item);
} else {
item.p *= (double)m;
}
}
return item.p;
}
int main() {
int m = 12, n = 8;
double p = fun(m, n);
printf("%.6lf", p);
return 0;
}
这个栈写法使用了一个栈来保存中间结果,以便进行回溯。难点在于需要注意栈的初始化、入栈和出栈操作,以及回溯的条件和计算公式。
解法七:C语言代码:队列写法
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int m;
int n;
double p;
} Item;
typedef struct {
int front;
int rear;
int size;
Item *data;
} Queue;
void init(Queue *q, int size) {
q->front = 0;
q->rear = 0;
q->size = size;
q->data = (Item*)malloc(size * sizeof(Item));
}
void enqueue(Queue *q, Item item) {
q->data[q->rear] = item;
q->rear = (q->rear + 1) % q->size;
}
Item dequeue(Queue *q) {
Item item = q->data[q->front];
q->front = (q->front + 1) % q->size;
return item;
}
int is_empty(Queue *q) {
return q->front == q->rear;
}
double fun(int m, int n) {
Queue q;
init(&q, n + 1);
Item item;
item.m = m;
item.n = n;
item.p = 1;
enqueue(&q, item);
while (!is_empty(&q)) {
item = dequeue(&q);
m = item.m;
n = item.n;
if (n == 0) {
item.p = 1;
} else if (n == 1) {
item.p = (double)m;
} else {
Item item1;
item1.m = m - 1;
item1.n = n - 1;
item1.p = 1;
enqueue(&q, item1);
Item item2;
item2.m = m - 1;
item2.n = n;
item2.p = 1;
enqueue(&q, item2);
}
item.p *= (double)m / (m - n + 1);
if (n > 1) {
enqueue(&q, item);
} else {
item.p *= (double)m;
}
}
return item.p;
}
int main() {
int m = 12, n = 8;
double p = fun(m, n);
printf("%.6lf", p);
return 0;
}
首先,在这段代码中,定义了两个结构体类型:Item和Queue。
其中,Item结构体表示一个组合问题中的一项,包括m、n、p三个成员变量,分别表示组合中的元素个数、选取的元素个数以及概率。Queue结构体表示一个队列,包括front、rear、size和data四个成员变量。其中,front和rear分别表示队列的头和尾,size表示队列的大小,data是一个指向Item类型数据的指针。
接着,在代码中定义了几个函数。init函数用于初始化队列,enqueue函数用于向队列中添加元素,dequeue函数用于从队列中取出元素,is_empty函数用于判断队列是否为空。这些函数都是对队列的基本操作,可以在其他程序中重复使用。
然后,在fun函数中,先创建一个队列q,并将初始状态加入队列中,初始状态即为m、n和p分别为函数参数m、n和1的Item结构体。然后,通过while循环不断从队列中取出元素,处理后再将新的元素加入队列中,直到队列为空为止。
在处理每个元素时,先从元素中取出m、n和p的值,判断n的值,如果n为0,则p为1;如果n为1,则p为m;否则,需要将元素分解成两个新的元素,分别表示选取了当前元素和未选取当前元素的情况,将这两个新元素加入队列中。
接着,计算当前元素的p值,即将m个元素选取n个元素的概率,通过公式(m!/(m-n)!n!)计算得出。如果n大于1,则将当前元素重新加入队列中;否则,p值再乘上m,即为最终的结果。
最后,在main函数中,设定m和n的值,调用fun函数计算出结果并输出。
在这段代码中,需要注意的是,队列中存储的元素是Item类型的结构体,需要注意结构体的初始化和赋值方式。同时,在计算概率时,需要注意数据类型转换和计算顺序。
这个队列写法和栈写法类似,只是使用了队列来保存中间结果。难点在于需要注意队列的初始化、入队和出队操作,以及回溯的条件和计算公式。
解法八:C语言代码:链表写法
#include <stdio.h>
#include <stdlib.h>
// 定义链表结构体
typedef struct Node {
int data;
struct Node* next;
} Node;
// 定义函数fun,使用递归方式计算P的值
double fun(int m, int n) {
if (n == 0 || n == m) {
return 1;
} else {
return fun(m - 1, n - 1) + fun(m - 1, n);
}
}
// 定义函数createList,创建一个长度为length的链表,并返回头结点指针
Node* createList(int length) {
Node* head = NULL;
Node* tail = NULL;
for (int i = 0; i < length; i++) {
Node* node = (Node*)malloc(sizeof(Node));
node->data = i;
node->next = NULL;
if (head == NULL) {
head = node;
} else {
tail->next = node;
}
tail = node;
}
return head;
}
// 定义函数freeList,释放整个链表的内存空间
void freeList(Node* head) {
while (head != NULL) {
Node* node = head;
head = head->next;
free(node);
}
}
int main() {
int m = 12, n = 8;
double p = fun(m, n) / 1.0;
printf("P = %.6f\n", p);
// 使用createList函数创建一个长度为10的链表,并打印每个节点的值
Node* head = createList(10);
Node* current = head;
while (current != NULL) {
printf("%d ", current->data);
current = current->next;
}
printf("\n");
// 释放链表的内存空间
freeList(head);
return 0;
}
在这段代码中,我们首先定义了一个结构体Node
,表示链表中的一个节点,其中包含一个整数data
和一个指向下一个节点的指针next
。然后,我们定义了一个函数fun
,使用递归方式计算P的值。这个函数的实现方式比较简单,就是按照公式P = (m!)/(n!(m-n)!)进行递归计算。如果n等于0或m等于n,直接返回1即可。否则,就递归调用fun函数,分别计算m-1和n-1以及m-1和n的值,并将它们相加。
接下来,我们定义了两个函数createList
和freeList
,分别用于创建链表和释放链表的内存空间。函数createList
接收一个参数length
,表示要创建的链表的长度。在函数内部,我们使用一个循环,创建length
个节点,并将它们连接成一个链表。每个节点的值都是当前的循环变量i
。函数freeList
接收一个参数head
,表示链表的头结点指针。在函数内部,我们使用一个循环,依次释放每个节点的内存空间,直到链表为空。
在主函数中,我们首先调用fun
函数,计算出P的值,并将结果赋值给变量p
。然后,我们使用printf
函数打印出P的值。接下来,我们使用createList
函数创建一个长度为10的链表,并打印出每个节点的值。最后,我们调用freeList
函数释放链表的内存空间。
解法九:C语言代码:
好的,下面是使用动态内存的C语言代码:
#include <stdio.h>
#include <stdlib.h>
double fun(int m, int n);
int main()
{
int m = 12, n = 8;
double p = fun(m, n);
printf("%.6f\n", p);
return 0;
}
double fun(int m, int n)
{
double *p, *q, *r;
int i, j;
p = (double *)malloc((m + 1) * sizeof(double)); // 申请动态内存
q = (double *)malloc((n + 1) * sizeof(double));
r = (double *)malloc((m - n + 1) * sizeof(double));
for (i = 0; i <= m; i++) {
p[i] = 1.0;
}
for (i = 1; i <= n; i++) {
q[i] = 1.0;
r[i] = 1.0;
}
for (i = 1; i <= m; i++) {
for (j = 1; j <= n; j++) {
if (i == j) {
q[j] = p[j] = 1.0;
} else {
q[j] = q[j - 1] * j;
p[j] = p[j - 1] * i;
}
}
for (j = 1; j <= m - n; j++) {
r[j] = r[j - 1] * (i - n);
}
}
double ans = p[n] / (q[n] * r[m - n]);
free(p); // 释放动态内存
free(q);
free(r);
return ans;
}
函数fun
的主要思路是利用动态内存分配来避免数组越界的问题。首先,我们根据公式申请三个动态内存,分别存储m
、n
、m-n
的阶乘。然后,我们利用三个循环分别计算三个阶乘的值,并将结果存储在相应的数组中。最后,按照公式计算P
的值,并释放动态内存。
在代码实现过程中,需要注意以下几个问题:
- 动态内存的申请和释放必须对应,否则会出现内存泄漏或者非法访问的问题;
- 需要注意循环的起始和终止条件,否则会出现数组越界的问题;
- 在计算阶乘的过程中,需要特别处理
0!
和1!
的情况; - 在计算
P
的过程中,需要注意先后顺序和数据类型的转换。