C语言高分

㈠ c语言,高分

一看就知道是数据结构的作业题。。。
给你第一题的参考答案吧。。其他努力做完。。
typedef enum{"男"=0,"女"=1}sex;
strust student
{
int num;
char name[255];
sex user_sex;
int score[3];

}

㈡ C语言高分急求

1. x+=1;
2. ((x>5)||(x<-5))?TRUE:FALSE
3. double
4. 25 21 37
5. -3
6. i=10,j=20
7. 数组成员个数
8. j=i

㈢ 如何能c语言考试得高分就是大一计算机系的期末考试，难度中等偏上！追加100，决不食言！

多练。上机时和助教搞好关系，每次都提前做完，第一个验收。我就是这样做得了97.

㈣ C语言 高分

我都帮你调试过了`
第一个：
#include <stdio.h>
#include <stdlib.h> //下面的system函数要用
main()
{
int a[10],max,i;
for(i=0;i<10;i++)
scanf("%d",&a[i]);
max=a[0];
for(i=0;i<10;i++)
if(max<a[i])
max=a[i];
printf("max=%d\n",max);
system("pause"); //程序运行到这暂停的意思
}
第二个；
#include <stdio.h>
#include <stdlib.h>
main()
{
int i;
float s;
s=1;
for(i=2;i<=100;i++)
{
if(i%2)
s=s+1/i;
else
s=s-1/i;
}
printf("s=%f",s);
system("pause"); //程序运行到这里暂停一下
}
都帮你调试了 ALT+C直接可以上`

㈤ C语言（高分）

//第一个最复杂点，我做了。~！
//=================================

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
typedef struct caipan
{ char id[6];
double score;
double cha;
};
caipan ydy[8];

int ssort()
{ int i,j;
caipan temp;
for(i=7;i>=0;i--)
{temp=ydy[0];
for(j=0;j<=i;j++)
if(ydy[j].score>ydy[j+1].score){
temp=ydy[j];
ydy[j]=ydy[j+1];
ydy[j+1]=temp;
}
}
}

double sabs(double i)
{
if(i<0)return -i;
return i;
}

int main()
{ int n,i,j,k;
double sin,s=0,avg,near=100;
for(i=0;i<8;i++)
{
printf("输入第%d个裁判ID：",i+1);
scanf("%s",ydy[i].id);
printf("输入第%d个裁判的打分：",i+1);
scanf("%lf",&ydy[i].score);
}
ssort();
for(i=1;i<7;i++)s+=ydy[i].score;
avg=s/6;
printf("平均分：%.2lf\n",avg);

for(i=1;i<7;i++)ydy[i].cha=sabs(ydy[i].score-avg);
for(i=1;i<7;i++)
if(ydy[i].cha<near)
{
near=ydy[i].cha;
k=i;
}
printf("最接近平均分的裁判ID是：%s 号!\n",ydy[k].id);

system("pause");

}

//=======第二题，【回答者： xemoaya - 同进士出身 六级】的写的问题============ 太长就不行。

#include<stdio.h>
#include<stdlib.h>
int main()
{
char num[1000]={'\0'},*p,*q;
int i,t=0;
scanf("%s",num);
q=p=num;
while(*p!='\0')t++,p++;
for(i=0;i<t;i++,q++)
{
if(i!=0&&i!=t&&(t-i)%3==0)printf(",");
printf("%c",*q);
}
printf("\n");
system("pause");
}

㈥ c语言 高分

头文件一般由三部分内容组成：(1)头文件开头处的版权和版本声明；(2)预处理块；(3)函数和类结构声明等。在头文件中，用 ifndef/define/endif结构产生预处理块，用 #include 格式来引用库的头文件。

头文件的主要作用在于调用库功能，对各个被调用函数给出一个描述，其本身不包含程序的逻辑实现代码，它只起描述性作用，告诉应用程序通过相应途径寻找相应功能函数的真正逻辑实现代码。用户程序只需要按照头文件中的接口声明来调用库功能，编译器会从库中提取相应的代码。

头文件是用户应用程序和函数库之间的桥梁和纽带。在整个软件中，头文件不是最重要的部分，但它是C语言家族中不可缺少的组成部分。做一个不算很恰当的比喻，头文件就像是一本书中的目录，读者(用户程序)通过目录，可以很方便就查阅其需要的内容(函数库)。在一本书中，目录固然重要，但绝对不是一本书的核心的、最重要的部分。

所以头文件不是一般都被include在源文件的开头，而是必须都被include在源文件的开头

㈦ 问下计算机二级C语言如何考高分

首先要一台计算机，我们接触的一般都是windows系统，考试的时候也是windows系统。计算机上要安装一个软件，叫visual c++ 6.0,网上搜一下，有绿色版的。
考试你要看书，看什么书要看你要深入到什么程度。
如果是就过了考试的话，那么你要购买三本书，《全国计算机等级考试二级教程——公共基础知识》、《全国计算机等级考试二级教程——C语言程序设计》，这两本都是教育部考试中心编写，高等教育出版社出版的，是指定教材。
还有一本是《全国计算机等级考试上级考试习题集二级C语言程序设计》
如果过考试还不够，要在C语言上下工夫的话，就介绍一本C Primer Plus(中文版)(第5版)，这个是外国人写的，C语言入门是够的。
必须把《全国计算机等级考试二级教程——C语言程序设计》看2-3遍，因为这个占的比重很大，而《全国计算机等级考试二级教程——公共基础知识》要抓重点看，这个主要是选择题会出。
如果买了习题的话，建议多做做习题，多用用visual c++写写软件，要适应这个软件，上级就是用这个的。
没有买习题，要多做模拟系统，利用里面的题来代替。买了习题的，也要用模拟系统模拟几遍，可以估计下水平。

㈧ c语言（高分）

1.相对于递归算法,递推算法免除了数据进出栈的过程，也就是说,不需要函数不断的向边界值靠拢,而直接从边界出发,直到求出函数值.
比如阶乘函数：f(n)=n*f(n-1)
在f(3)的运算过程中,递归的数据流动过程如下:
f(3){f(i)=f(i-1)*i}-->f(2)-->f(1)-->f(0){f(0)=1}-->f(1)-->f(2)--f(3){f(3)=6}
而递推如下:
f(0)-->f(1)-->f(2)-->f(3)
由此可见,递推的效率要高一些,在可能的情况下应尽量使用递推.但是递归作为比较基础的算法,它的作用不能忽视.所以,在把握这两种算法的时候应该特别注意.
2.所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
分类
在计算机科学所使用的排序算法通常被分类为：
计算的复杂度（最差、平均、和最好表现），依据串行（list）的大小（n）。一般而言，好的表现是O。(n log n)，且坏的行为是Ω(n2)。对于一个排序理想的表现是O(n)。仅使用一个抽象关键比较运算的排序算法总平均上总是至少需要Ω(n log n)。
记忆体使用量（以及其他电脑资源的使用）
稳定度：稳定排序算法会依照相等的关键（换言之就是值）维持纪录的相对次序。也就是一个排序算法是稳定的，就是当有两个有相等关键的纪录R和S，且在原本的串行中R出现在S之前，在排序过的串行中R也将会是在S之前。
一般的方法：插入、交换、选择、合并等等。交换排序包含冒泡排序（bubble sort）和快速排序（quicksort）。选择排序包含shaker排序和堆排序（heapsort）。
当相等的元素是无法分辨的，比如像是整数，稳定度并不是一个问题。然而，假设以下的数对将要以他们的第一个数字来排序。
(4, 1) (3, 1) (3, 7) (5, 6)
在这个状况下，有可能产生两种不同的结果，一个是依照相等的键值维持相对的次序，而另外一个则没有：
(3, 1) (3, 7) (4, 1) (5, 6) (维持次序)
(3, 7) (3, 1) (4, 1) (5, 6) (次序被改变)
不稳定排序算法可能会在相等的键值中改变纪录的相对次序，但是稳定排序算法从来不会如此。不稳定排序算法可以被特别地时作为稳定。作这件事情的一个方式是人工扩充键值的比较，如此在其他方面相同键值的两个物件间之比较，就会被决定使用在原先资料次序中的条目，当作一个同分决赛。然而，要记住这种次序通常牵涉到额外的空间负担。
排列算法列表
在这个表格中，n是要被排序的纪录数量以及k是不同键值的数量。
稳定的
冒泡排序（bubble sort） — O(n2)
鸡尾酒排序 (Cocktail sort, 双向的冒泡排序) — O(n2)
插入排序 （insertion sort）— O(n2)
桶排序 （bucket sort）— O(n); 需要 O(k) 额外 记忆体
计数排序 (counting sort) — O(n+k); 需要 O(n+k) 额外 记忆体
归并排序 （merge sort）— O(n log n); 需要 O(n) 额外记忆体
原地归并排序 — O(n2)
二叉树排序 （Binary tree sort） — O(n log n); 需要 O(n) 额外记忆体
鸽巢排序 (Pigeonhole sort) — O(n+k); 需要 O(k) 额外记忆体
基数排序 （radix sort）— O(n·k); 需要 O(n) 额外记忆体
Gnome sort — O(n2)
Library sort — O(n log n) with high probability, 需要 (1+ε)n 额外记忆体
不稳定
选择排序 （selection sort）— O(n2)
希尔排序 （shell sort）— O(n log n) 如果使用最佳的现在版本
Comb sort — O(n log n)
堆排序 （heapsort）— O(n log n)
Smoothsort — O(n log n)
快速排序 （quicksort）— O(n log n) 期望时间, O(n2) 最坏情况; 对于大的、乱数串行一般相信是最快的已知排序
Introsort — O(n log n)
Patience sorting — O(n log n + k) 最外情况时间, 需要 额外的 O(n + k) 空间, 也需要找到最长的递增子序列（longest increasing subsequence）
不实用的排序算法
Bogo排序 — O(n × n!) 期望时间, 无穷的最坏情况。
Stupid sort — O(n3); 递回版本需要 O(n2) 额外记忆体
Bead sort — O(n) or O(√n), 但需要特别的硬体
Pancake sorting — O(n), 但需要特别的硬体
排序的算法
排序的算法有很多，对空间的要求及其时间效率也不尽相同。下面列出了一些常见的排序算法。这里面插入排序和冒泡排序又被称作简单排序，他们对空间的要求不高，但是时间效率却不稳定；而后面三种排序相对于简单排序对空间的要求稍高一点，但时间效率却能稳定在很高的水平。基数排序是针对关键字在一个较小范围内的排序算法。
插入排序
冒泡排序
选择排序
快速排序
堆排序
归并排序
基数排序
希尔排序
插入排序
插入排序是这样实现的：
首先新建一个空列表，用于保存已排序的有序数列（我们称之为"有序列表"）。
从原数列中取出一个数，将其插入"有序列表"中，使其仍旧保持有序状态。
重复2号步骤，直至原数列为空。
插入排序的平均时间复杂度为平方级的，效率不高，但是容易实现。它借助了"逐步扩大成果"的思想，使有序列表的长度逐渐增加，直至其长度等于原列表的长度。
冒泡排序
冒泡排序是这样实现的：
首先将所有待排序的数字放入工作列表中。
从列表的第一个数字到倒数第二个数字，逐个检查：若某一位上的数字大于他的下一位，则将它与它的下一位交换。
重复2号步骤，直至再也不能交换。
冒泡排序的平均时间复杂度与插入排序相同，也是平方级的，但也是非常容易实现的算法。
选择排序
选择排序是这样实现的：
设数组内存放了n个待排数字，数组下标从1开始，到n结束。
i=1
从数组的第i个元素开始到第n个元素，寻找最小的元素。
将上一步找到的最小元素和第i位元素交换。
如果i=n－1算法结束，否则回到第3步
选择排序的平均时间复杂度也是O(n²)的。
快速排序
现在开始，我们要接触高效排序算法了。实践证明，快速排序是所有排序算法中最高效的一种。它采用了分治的思想：先保证列表的前半部分都小于后半部分，然后分别对前半部分和后半部分排序，这样整个列表就有序了。这是一种先进的思想，也是它高效的原因。因为在排序算法中，算法的高效与否与列表中数字间的比较次数有直接的关系，而"保证列表的前半部分都小于后半部分"就使得前半部分的任何一个数从此以后都不再跟后半部分的数进行比较了，大大减少了数字间不必要的比较。但查找数据得另当别论了。
堆排序
堆排序与前面的算法都不同，它是这样的：
首先新建一个空列表，作用与插入排序中的"有序列表"相同。
找到数列中最大的数字，将其加在"有序列表"的末尾，并将其从原数列中删除。
重复2号步骤，直至原数列为空。
堆排序的平均时间复杂度为nlogn,效率高（因为有堆这种数据结构以及它奇妙的特征，使得"找到数列中最大的数字"这样的操作只需要O(1)的时间复杂度，维护需要logn的时间复杂度），但是实现相对复杂（可以说是这里7种算法中比较难实现的）。
看起来似乎堆排序与插入排序有些相像，但他们其实是本质不同的算法。至少，他们的时间复杂度差了一个数量级，一个是平方级的，一个是对数级的。
平均时间复杂度
插入排序 O(n2)
冒泡排序 O(n2)
选择排序 O(n2)
快速排序 O(n log n)
堆排序 O(n log n)
归并排序 O(n log n)
基数排序 O(n)
希尔排序 O(n1.25)
3.索引查找是在索引表和主表(即线性表的索引存储结构)上进行的查找。索引查找的过程是：首先根据给定的索引值K1，在索引表上查找出索引值等于KI的索引项，以确定对应予表在主表中的开始位置和长度，然后再根据给定的关键字K2，茬对应的子表中查找出关键字等于K2的元素(结点)。对索引表或子表进行查找时，若表是顺序存储的有序表，则既可进行顺序查找，也可进行二分查找，否则只能进行顺序查找。
设数组A是具有mainlist类型的一个主表，数组B是具有inde)dist类型的在主表A 上建立的一个索引表，m为索引表B的实际长度，即所含的索引项的个数，KI和K2分别为给定待查找的索引值和关键字(当然它们的类型应分别为索引表中索引值域的类型和主表中关键字域在索引存储中，不仅便于查找单个元素，而且更便于查找一个子表中的全部元素。当需要对一个子袁中的全部元素依次处理时，只要从索引表中查找出该子表的开始位
置即可。由此开始位置可以依次取出该子表中的每一个元素，所以整个查找过程的时间复杂度为，若不是采用索引存储，而是采用顺序存储，即使把它组织成有序表而进行二分查找时，索引查找一个子表中的所有元素与二分查找一个子表中的所有元素相比。
若在主表中的每个子表后都预留有空闲位置，则索引存储也便于进行插入和删除运算，因为其运算过程只涉及到索引表和相应的子表，只需要对相应子表中的元素进行比较和移动，与其它任何子表无关，不像顺序表那样需涉及到整个表中的所有元素，即牵一发而动全身。
在线性表的索引存储结构上进行插入和删除运算的算法，也同查找算法类似，其过程为：首先根据待插入或删除元素的某个域(假定子表就是按照此域的值划分的)的值查找索引表，确定出对应的子表，然后再根据待插入或删除元素的关键字，在该子表中做插入或删除元素的操作。因为每个子表不是顺序存储，就是链接存储，所以对它们做插入或删除操作都是很简单的。
4.插入法排序
#define N 10
#include"stdio.h"
main()
{ int i,j,k,t,a[N];
clrscr();
printf("Please input %d numbers:\n",N);
for(i=0;i<N;i++)
scanf("%d",&a[i]);
for(i=1;i<N;i++)
{
for(j=0;j<i;j++)
{if(a[j]>a[i])
{t=a[i];
for(k=i;k>=j;k--)
a[k]=a[k-1];
a[j]=t;
}
}
}
printf("small to big order:\n");
for(i=0;i<N;i++)
printf("%-2d",a[i]);
printf("\n");
getch();
}

㈨ C语言高分

改后源程序如下：
#include <stdio.h>

#include <string.h>

#define MaxSize 100

typedef struct
{
char s[MaxSize];

}ST;

ST *st;

int top=0;

void push(char *x,char *y);

char pop();

void translate();

void push(char *x,char *y)

{

while((y+1)!=x)

st->s[top++]=*y--;

}

char pop()

{

return(st->s[top--]);

}

void translate()

{
char e;

printf("\n");

while(top>=0)

{

e=pop();

if(e=='B') printf("tsaedsae");

else if(e=='A') printf("sae");

else if(e=='('||e==')') continue;

else printf("%c",e);

}

printf("\n\nover!\n");

getch();

}

void main()

{

char *p,*p0;

char str[MaxSize];

p0=p=str;

printf("\nyo wang yuan li:1.B --> tAdA 2.A --> sae\n");

printf("\nni yu:\n\ninput-->A(B)a \n\ntranf--

>saetsaedsaea\n");

printf("\ninput mo wang yu yan:");

scanf("%s",p);

while(*p!='\0')

p++;

push(p0,p);

translate();

}
输入：1 2 3 4 5 6
输出：1
over!

㈩ C语言 有高分

以上几位的回答都有错误：

#include "Stdio.h"
#include "Conio.h"
包含两个头文件（而不是类，也不是函数库）以便调用在这两个文件中声明的库函数。

stdio.h中声明的是标准库函数，在所有的C系统中可以直接调用。
conio.h中声明的不是标准库函数，它们是微软提供的函数，可以在微软的操作系统中调用。

main()函数是C程序必须要有的一个函数，而且在同一程序中只能有一个，C程序的执行就从这个函数开始，它可以调用其它函数，main前面的int表示这个函数将返回一个整数，后面的(void)表示这个函数不接受参数。