本文目录一览：
- 1、C语言高斯-塞德尔迭代法
- 2、c语言中什么是算法？有哪些描述算法的例子？
- 3、求遗传算法（GA）C语言代码
- 4、c语言常用算法有哪些
- 5、C语言的算法描述是什么?
- 6、c语言题目,算法看不懂，还有里面的sigh和sum等都是什么意思啊~！希望一步一步的说清楚，先谢啦~！
C语言高斯-塞德尔迭代法
#include stdio.h
int main()
{
double x[4] = {0, 0, 0, 0};
double a[4][4] = {1, 2, 4, 8, 1, 3, 9, 27, 1, 4, 16, 64, 1, 5, 25, 125};
double y[4] = {10, 26, 58, 112};
double d[4][4], g[4];
int round = 5, i,j;
for (i=0; i4; ++i) {
g[i] = y[i] / a[i][i];
for (j=0; j4; ++j) {
d[i][j] = i==j ? 0 : -a[i][j]/a[i][i];
}
}
while (round--) {
for (i=0; i4; ++i) {
x[i] = g[i];
for (j=0; j4; ++j) {
x[i] += d[i][j] * x[j];
}
printf("%lf " , x[i]);
}
printf("\n");
}
}
c语言中什么是算法？有哪些描述算法的例子？
c语言中的算法是指：一系列解决问题的清晰指令，用系统的方法描述解决问题的策略机制。也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。通俗说就是解决问题的方法和步骤。
描述算法的例子：
问题：从上海去到北京。
其中的算法：做汽车、做飞机、或者徒步。
问题：喝茶。
其中的算法：先找到茶叶，再烧一壶开水，然后将茶叶放到杯子里，将开水倒入杯中，等茶叶泡好。
问题：开车。
其中的算法：首先要打开车门，驾驶员坐好，插上车钥匙，发动汽车。
算法的五个重要的特征：有穷性（Finiteness）、确切性(Definiteness)、输入项(Input)、输出项(Output)、可行性(Effectiveness)。
算法的时间复杂度：算法的时间复杂度是指执行算法所需要的计算工作量。一般来说，计算机算法是问题规模n 的函数f(n)，算法的时间复杂度也因此记做。T(n)=Ο(f(n))因此，问题的规模n 越大，算法执行的时间的增长率与f(n) 的增长率正相关，称作渐进时间复杂度（Asymptotic Time Complexity）。
算法的空间复杂度：算法的空间复杂度是指算法需要消耗的内存空间。其计算和表示方法与时间复杂度类似，一般都用复杂度的渐近性来表示。同时间复杂度相比，空间复杂度的分析要简单得多。可以从正确性、可读性、健壮性（容错性）来分析。
求遗传算法（GA）C语言代码
x=220;
for(i=0;i12;i++)
{
y=202+i*16;
for(j=bits [ i][0];j=bits [ i][1];j++)
if(g[j]==0)
g_text(x+(j-bits [ i][0])*16,y,4,"0");
else
g_text(x+(j-bits [ i][0])*16,y,4,"1");
}
}
}
void g_disp_char(x,y,x1,y1,x2,y2,v)
int x,y,x1,y1,x2,y2;
unsigned char v;
{
char c[10];
if(x=x1 x=x2-8 y=y1 y=y2-10)
{
switch(v)
{
case 0: strcpy(c,"0");break;
case 1: strcpy(c,"+");break;
case 2: strcpy(c,"-");break;
case 3: strcpy(c,"x");
}
g_text(x,y,15,c);
}
}
void remove_life(n) /* 消除第n个个体 */
int n;
{
iflg[n]=0;
world[iatr[n][0]][iatr[n][1]]=0;
g_disp_unit(iatr[n][0],iatr[n][1],0);
if(food_size+1=MAX_FOOD)
{
food_size++;
fatr[food_size-1][0]=iatr[n][0];
fatr[food_size-1][1]=iatr[n][1];
fatr[food_size-1][2]=1;
fatr[food_size-1][3]=0;
fflg[food_size-1]=1;
world[iatr[n][0]][iatr[n][1]]=5;
g_disp_unit(iatr[n][0],iatr[n][1],5);
}
}
void remove_food(n) /* 消除第n个食物 */
int n;
{
fflg[n]=0;
world[fatr[n][0]][fatr[n][1]]=0;
g_disp_unit(fatr[n][0],fatr[n][1],0);
}
void make_lives_and_foods() /* 设置虚拟环境中生物与食物 */
{
int x,y,i,j;
pop_size=0;
food_size=0;
for(y=0;ywy;y++)
for(x=0;xwx;x++)
{
if(world[x][y]==1||world[x][y]==2)
{
if(pop_size+1=MAX_POP)
{
pop_size++;
/* 生成遗传因子 */
gene[pop_size-1][0]=world[x][y]-1;
for(i=1;iG_LENGTH;i++)
gene[pop_size-1] [ i]=random(2);
/* 设定属性 */
iatr[pop_size-1][0]=x;
iatr[pop_size-1][1]=y;
iatr[pop_size-1][2]=70+random(30);
iatr[pop_size-1][3]=random(SL_MIN);
}
}
if(world[x][y]==3||world[x][y]==5)
{
if(food_size+1=MAX_FOOD)
{
food_size++;
/* 设定属性 */
fatr[food_size-1][0]=x;
fatr[food_size-1][1]=y;
if(world[x][y]==3)
fatr[food_size-1][2]=0;
else
fatr[food_size-1][2]=1;
fatr[food_size-1][3]=random(TL1-1)+1;
}
}
}
}
void find_empty(x,y) /* 寻找虚拟环境中的空处，返回坐标 */
int *x,*y;
{
int ok;
ok=0;
while(ok==0)
{
*x=random(wx);*y=random(wy);
if(world[*x][*y]==0) ok=1;
}
}
void make_world() /* 随机设定人工环境 */
{
int i,j,k,num,x,y;
int ok,overlap;
char choice[3];
double size;
wx=0;
while(wx10||wxMAX_WX)
{
setcolor(15);
disp_hz16("虚拟环境长度(10-60)",10,210,20);
gscanf(300,210,4,0,3,"%s",choice);
wx=atoi(choice);
}
wy=0;
while(wy10||wyMAX_WY)
{
setcolor(15);
disp_hz16("虚拟环境宽度(10-32)",10,240,20);
gscanf(300,240,4,0,3,"%s",choice);
wy=atoi(choice);
}
for(i=0;iwy;i++)
for(j=0;jwx;j++)
if(i==0||i==wy-1||j==0||j==wx-1)
world[j] [ i]=4;
else world[j] [ i]=0;
/* 设定障碍物 */
size=(double)(wx*wy);
num=(int)(size/40.0);
if(numMAX_POP) num=MAX_POP;
for(i=0;inum;i++)
{
find_empty(x,y);
world[x][y]=4;
}
num=(int)(size/5.0);
if(numMAX_FOOD) num=MAX_FOOD;
for(i=0;inum;i++)
{
ok=0;
while(ok==0)
{
x=random(wx);y=random(wy);
if((world[x][y]!=4)
(world[x][y-1]==4 || world[x][y+1]==4 ||
world[x-1][y]==4 || world[x+1][y]==4))
{ world[x][y]=4;
ok=1;
}
}
}
for(y=0;ywy;y++)
for(x=0;xwx;x++)
if(world[x][y]==0)
{
num=0;
for(i=-1;i=1;i++)
for(j=-1;j=1;j++)
if(get_world(x+j,y+i)==4)
num++;
if(num=6) world[x][y]=4;
}
/* 设定生物 */
num=(int)(size*R_LIFE);
for(i=0;inum;i++)
{ find_empty(x,y);
world[x][y]=random(2)+1;
}
/* 设定食物 */
num=(int)(size*R_FOOD);
for(i=0;inum;i++)
{
find_empty(x,y);
world[x][y]=3;
}
}
void load_world_file() /* 读取虚拟环境数据文件设定 */
{
FILE *fopen(),*fpt;
char st[100],c;
int i,j;
if((fpt=fopen("\ga\world","r"))==NULL) exit(-1);
else
{
fscanf(fpt,"%d",wx);
fscanf(fpt,"%d",wy);
for(i=0;iwy;i++)
for(j=0;jwx;j++)
fscanf(fpt,"%d",world[j] [ i]);
fclose(fpt);
c语言常用算法有哪些
0） 穷举法
穷举法简单粗暴，没有什么问题是搞不定的，只要你肯花时间。同时对于小数据量，穷举法就是最优秀的算法。就像太祖长拳，简单，人人都能会，能解决问题，但是与真正的高手过招，就颓了。
1） 贪婪算法
贪婪算法可以获取到问题的局部最优解，不一定能获取到全局最优解，同时获取最优解的好坏要看贪婪策略的选择。特点就是简单，能获取到局部最优解。就像打狗棍法，同一套棍法，洪七公和鲁有脚的水平就差太多了，因此同样是贪婪算法，不同的贪婪策略会导致得到差异非常大的结果。
2） 动态规划算法
当最优化问题具有重复子问题和最优子结构的时候，就是动态规划出场的时候了。动态规划算法的核心就是提供了一个memory来缓存重复子问题的结果，避免了递归的过程中的大量的重复计算。动态规划算法的难点在于怎么将问题转化为能够利用动态规划算法来解决。当重复子问题的数目比较小时，动态规划的效果也会很差。如果问题存在大量的重复子问题的话，那么动态规划对于效率的提高是非常恐怖的。就像斗转星移武功，对手强它也会比较强，对手若，他也会比较弱。
3）分治算法
分治算法的逻辑更简单了，就是一个词，分而治之。分治算法就是把一个大的问题分为若干个子问题，然后在子问题继续向下分，一直到base cases，通过base cases的解决，一步步向上，最终解决最初的大问题。分治算法是递归的典型应用。
4） 回溯算法
回溯算法是深度优先策略的典型应用，回溯算法就是沿着一条路向下走，如果此路不同了，则回溯到上一个
分岔路，在选一条路走，一直这样递归下去，直到遍历万所有的路径。八皇后问题是回溯算法的一个经典问题，还有一个经典的应用场景就是迷宫问题。
5） 分支限界算法
回溯算法是深度优先，那么分支限界法就是广度优先的一个经典的例子。回溯法一般来说是遍历整个解空间，获取问题的所有解，而分支限界法则是获取一个解（一般来说要获取最优解）。
C语言的算法描述是什么?
有很多种形式，比如用伪代码来叙述你的编程思想.
主要包含内部逻辑，数据流处理.
c语言题目,算法看不懂，还有里面的sigh和sum等都是什么意思啊~！希望一步一步的说清楚，先谢啦~！
看来这个问题难住你的不是算法本身，而是英文， 程序员需要良好的英语基础和数学基础。
sign：
中文含义 为符号， 用来代表这个算法里面的当前 正负号；
sum:
中文含义为总和， 用来代表求和的和。
deno:
denominator 的缩写，denominator中文含义为分母。
有了上面的解释，这个算法的伪代码相信就很容易懂了
1-1/2+1/3-1/4+.....1/99-1/100
= 1 + （-1）（1/2）+ 1/3 + (-1)(1/4) + ... + 1/99 + (-1)(1/100)
S1: 设为正数
S2: 和 = 1 //加上第一个数
S3: 分母为2 // 为了接着计算 (-1)(1/2)
S4: 正负变号//对应上面的算式每项轮流反号
S5：让term 为当前项 //现在是 (-1)(1/2)
S6: 这步写错了，应该是sum = sum + term, 即在和上加上当前项(-1)(1/2)，于是计算出了 1 + （-1）（1/2）的值了，目前
S7: 分母+1//为了计算 后面的1/3
S8： 如果分母小于等于100， 返回S4,这样可以继续计算并累加后面的项； 否则，当前的sum里已经包含了所有项的和了，结束。
