㈠ 几种c语言优化代码技巧
以下内容摘自李亚锋先生的《经典C面试真题精讲》
1.结构体设计为成员最长类型长度的整数倍；
2.减少函数参数的个数，不需要返回值的函数定义为void类型；
3.if...else....多条件分支语句中，把出现频率高的条件放在前面；
4.同时声明多个相同类型变量优于分别单独声明变量；
5.减少定义全局变量；
6.使用#define定义常量和小的函数实现；
7.有些情况嵌套汇编语句效率更高；
8.占用大的存储空间可以减少执行时间，同理时间也可以换取空间；
9提高程序算法效率；
㈡ c语言算法优化
【算法描述】
转某牛人的解题报告！！！！
这道题在没看数据规模之前以为是一道简单的DP，但是数据开到十亿，无论在时间还是空间复杂度都过大，所以就要进行优化了。
解一：
简单方法：预期得分30。简单动态规划，f[i]代表青蛙跳到i点时所可能踩到的最少石子数，所以有f[i]=min{f[k]+map[i]}(i-s≤k≤i-t)，其中map[i]代表i上是否有石子，有是1，否则0。算法复杂度O(n^2)。
解二：
改进方法：预期得分100。我们会发现，虽然桥很长，但上面最多只有100个石子，想到能否用石子DP，而应该是不行的。那能否基于第一种方法？由于石子排布非常的疏，我们还会发现，如果两个石子相隔甚远，那他们中间的f[i]大部分将会是同一个数，能否把两个石子的距离缩短，使之还与原来等效？要是行的话怎么缩？王乃岩同学考试时做了一个方法能够过全部数据，用的滚动数组存储，下面列出了他的程序。我自己也写了个程序，和他不尽相同：我令L=stone[i]-stone[i-1]（stone[i]代表按坐标由小到大顺序排列的石块坐标），当L能够被t整除时（L%t==0），令k=t；当L不能被t整除时（L%t!=0），令k=L%t。然后令k为k+t，最后判断如果k>L，那么map[]数组中stone[i]和stone[i-1]两石头的距离就被等效成为L（也就是没变）；如果k<=L，那么map[]数组中stone[i]和stone[i-1]两石头的距离就被等效成为k，可以看出来，这样处理完，两石子最大间距为2*t，大大的缩短了数组，再按解一进行DP，就可以通过了。
#include <stdio.h>
#include <string.h>
long stone[101];
int map[100001];
int f[100001];
long L;
int S, T, M;
void quickSort(int l, int r)
{
int i , j;
long temp;
i = l;
j = r;
temp = stone[i];
while (i < j)
{
while (i < j && stone[j] > temp)
j--;
if (i < j)
{
stone[i] = stone[j];
i++;
}
while (i < j && stone[i] < temp)
i++;
if (i < j)
{
stone[j] = stone[i];
j--;
}
}
stone[i] = temp;
if (i - 1 > l) quickSort(l, i - 1);
if (i + 1 < r) quickSort(i + 1, r);
}
int main()
{
int i, j;
long l, k, p = 0, min;
scanf("%ld%d%d%d", &L, &S, &T, &M);
for (i = 1; i <= M; i++)
scanf("%ld", &stone[i]);
memset(map, 0, sizeof(int)*100001);
memset(f, 0, sizeof(int)*100001);
quickSort(1, M);
stone[0] = 0;
p = 0;
for (i = 1; i <= M; i++)
{
l = stone[i] - stone[i - 1];
if (l % T == 0)
k = T;
else
k = l % T;
k = k + T;
if (l < k)
k = l;
p = p + k;
map[p] = 1;
}
for (i = 1; i <= p + T; i++)
{
min = 1000;
for (j = i - T; j <= i - S; j++)
if ( j >= 0 && f[j] < min)
min = f[j];
f[i] = min + map[i];
}
min = 1000;
for (i = p + 1; i <= p + T; i++)
if (f[i] < min)
min = f[i];
printf("%d\n", min);
return 0;
}
㈢ c语言代码优化
#include"stdio.h"
#include"stdlib.h"
#include"time.h"
void main()
{
int i,j,m,n,result;
void tsy(int n);
srand(time(NULL));
i=1+rand()%3;
j=4+rand()%3; //这里除3余数
m=1+rand()%9;
n=1+rand()%9;
printf("%d*%d\n",m,n);
printf("enter result:\n");
scanf("%d",&result);
if((m*n)==result)tsy(i);
else tsy(j);
printf("\n");
}
void tsy(int n)
{
switch(n)
{
case 1:{printf("Very good!\n");break;}
case 2:{printf("Excellent!\n");break;}
case 3:{printf("Keep up the good work!\n");break;}
case 4:{printf("No,please try again!\n");break;}
case 5:{printf("Wrong ,Try once more!\n");break;}
case 6:{printf("No.keep trying!\n");break;}
default:break;
}
}
㈣ 这个C语言程序怎么优化比较好
缓冲区、内存拷贝的话，直接用 内存拷贝函数 memcpy即可， 使用C标准库中的函数比较简洁。
自己写的话，把函数声明放在源文件的最上面比较直观。
㈤ C语言 最优化问题
这个code就是要表达一下的思维:
每一个订单是用一个长达200宽度的数字array 来表达的.
这有N个这样的订单.
每一个array， 我们在客户需要使用房间的那几天我们做如下行为:
我们表明每一天此客户需要使用多少个房间..如果是3个就是3个.
我们处理这个2维列阵如下:
把它画出来, 我们把每一列上面的数字都加起来, 从1到200, 然后一个一个比较, 算出来最大的那个总合. 那就是我们要的答案.
#include <iostream>
using namespace std;
int main (void) {
//样本数量
int N, iterator;
cin >> N;
iterator = 0;
/*最多是从第180天开始做20天*/
/*然后这里有N个订单*/
int howShouldINameThis[N][200];
/*每一个订单是用一个列阵来代表的*/
/*下面这些编码主要的意思就是将每一个列阵中客户要用房间的那些天做如下标记*/
/*如果他每天要用3个房间， 那么他/她要用房间的那些天就会全部被写上3*/
/*下面的编码会吸收所有的输入*/
while ( iterator < N ) {
int num1, num2, num3, sum;
cin >> num1 >> num2 >> num3;
sum = num2 + num3;
for ( num2; num2 < sum; num2 ++ )
{
howShouldINameThis[iterator][num2] = num1;
}
iterator ++;
}
/*此时我们有一个2维列阵，和N订单数量.*/
int minRoomRequirement = 0, temp = 0;
for (int i = 0; i < 200; i ++) {
for (int i2 = 0; i2 < N; i2 ++) {
temp += howShouldINameThis[i2][i]
}
if ( temp > minRoomRequirement )
minRoomRequirement = temp;
}
/*minRoomRequirement这个时候有你需要的答案*/
cout << minRoomRequirement << endl;
return 0;
}
㈥ C语言算法时间优化问题
1、所有m个数据读入之后再一起统一排序，可以调用qsort或者自己写简单的冒泡，10万个以内应该很快的。
2、查询采用折半法，找到一个之后往前往后看看有多少个相同的。（或者先对步骤1的结果进行归并，然后再折半查询。具体看q的数量，如果不大的话就用前一种直接查，如果q和m相近也很大的，那么采用后一种。）
㈦ 简述C语言程序代码优化的几种方法
具体问题具体分析……或者看看重构方面的书籍。
㈧ 紧急求助C语言描述的数据结构,中的有一个查找方式是用一个虚拟的哨兵元素来优化算法
这个属于顺序表的查找
typedef int Elemtype;
//定义静态查找表的顺序存储结构
typedef struct
{
Elemtype key;
}Elem;
typedef struct
{
Elem *elem;//存储空间基址
int length;//表的长度
}SSTable;
bool EQ(Elemtype key1,Elemtype key2)
{
if(key1==key2)
{
return true;
}
return false;
}
//下面是查找函数
int Search_Seq(SSTable ST, KeyType Key)
{
ST.elem[0].key=key;
for(i=ST.length;!EQ(ST.elem[i].key,key);--i);
return i;
}
我这里是将Elemtype定义为int 的，如果要定义为char，则应相应的更改EQ函数
㈨ 如果C语言函数参数太多，可以怎么优化
一个函数的参数的数目没有明确的限制，但是参数过多(例如超过8个)显然是一种不可取的编程风格。参数的数目直接影响调用函数的速度，参数越多，调用函数就越慢。另一方面，参数的数目少，程序就显得精练、简洁，这有助于检查和发现程序中的错误。因此，通常应该尽可能减少参数的数目，如果一个函数的参数超过4个，你就应该考虑一下函数是否编写得当。 如果一个函数不得不使用很多参数，你可以定义一个结构来容纳这些参数，这是一种非常好的解决方法。在下例中，函数print_report()需要使用10个参数，然而在它的说明中并没有列出这些参数，而是通过一个RPT_PARMS结构得到这些参数。 # include <atdio. h> typedef struct ( int orientation ; char rpt_name[25]; char rpt_path[40]; int destination; char output_file[25]; int starting_page; int ending_page; char db_name[25]; char db_path[40]; int draft_quality; )RPT_PARMS; void main (void); int print_report (RPT_PARMS* ); void main (void) { RPT_PARMS rpt_parm; /*define the report parameter structure variable * / /* set up the report parameter structure variable to pass to the print_report 0 function */ rpt_parm. orientation = ORIENT_LANDSCAPE; rpt_parm.rpt_name = "QSALES.RPT"; rpt_parm. rpt_path = "Ci\REPORTS" rpt_parm. destination == DEST_FILE; rpt_parm. output_file = "QSALES. TXT" ; rpt_parm. starting_page = 1; rpt_pann. ending_page = RPT_END; rpt_pann.db_name = "SALES. DB"; rpt_parm.db_path = "Ci\DATA"; rpt_pann. draft_quality = TRUE; /*call the print_report 0 function; paaaing it a pointer to the parameteM inatead of paMing it a long liat of 10 aeparate parameteM. * / ret_code = print_report(cu*pt_parm); } int print_report(RPT_PARMS*p) { int rc; /*acccM the report parametcra paaaed to the print_report() function */ oricnt_printcr(p->orientation); Kt_printer_quality((p->draft_quality == TRUE) ? DRAFT ; NORMAL); return rc; } 上例唯一的不足是编译程序无法检查引用print_report()函数时RPT_PARMS结构的10个成员是否符合要求。