演算法c語言

㈠ C語言 演算法

#include<stdio.h>
void main()
{
void f(int a);
f(15);
}
void f(int a)
{
int i = 0,b,u,s=1;
if(a==1)
printf("0\n");
else if(a==0)
printf("0");
else
{
b=a;
while(a>1)
{
a = a/2;
i++;
}
printf("%d\n",i);
for(u=0;u<i;u++)
s*=2;
f(b-s);
}
}
你的程序經過修改的，由於第一次遞歸是 f(a-s);中a已經變成了1，所以總是輸出1

㈡ 什麼是C語言的演算法

演算法是一系列解決問題的清晰指令，
換句話說就是能夠對一定規范的輸入，
在有限時間內獲得所要求的輸出。
演算法常常含有重復的步驟和一些比較或邏輯判斷。
if一個演算法有缺陷，or不適合於某個問題，
執行這個演算法將不會解決這個問題。
不同的演算法可能用不同的時間、空間或效率來完成同樣的任務。
一個演算法的優劣可以用空間復雜度與時間復雜度來衡量。
演算法的時間復雜度是指演算法需要消耗的時間資源。
一般來說，計算機演算法是問題規模n 的函數f(n)，演算法執行的時間的增長率與f(n) 的增長率正相關，稱作漸進時間復雜度（Asymptotic Time Complexity）。時間復雜度用「O（數量級）」來表示，稱為「階」。常見的時間復雜度有： O（1）常數階；O（log2n）對數階；O（n）線性階；O（n2）平方階。
演算法的空間復雜度是指演算法需要消耗的空間資源。
其計算和表示方法與時間復雜度類似，
一般都用復雜度的漸近性來表示。
同時間復雜度相比，空間復雜度的分析要簡單得多。

㈢ C語言中的演算法是指什麼

演算法（Algorithm）是指完成一個任務所需要的具體步驟和方法。也就是說給定初始狀態或輸入數據，能夠得出所要求或期望的終止狀態或輸出數據。
演算法常常含有重復的步驟和一些比較或邏輯判斷。不同的演算法可能用不同的時間、空間或效率來完成同樣的任務。一個演算法的優劣可以用空間復雜度與時間復雜度來衡量。
筆者學過數據結構就會對演算法更加了解。

㈣ C語言演算法

呵呵，先說說我吧，我買的書給你一個版本的！而且買書時間差不多不超過一個月，現在是高二學生（馬上要高三了），學起C語言並沒感覺到吃力！而我的一個同學就不同了，我們一起看的我都成了他老師了！當我看他看的時候才發現原因，他的速度是我看的3倍。這可能就是問題的所在了！建議樓主從書的目錄開始看，一字一句一個都不少，你會發現結果截然不同！就你所說的所運用的數學知識大多都是邏輯，如果有條件的話希望樓主惡補一下高中數學！但還是那句話，邏輯是程序的靈魂，成績並不能說明著什麼！

如果可以的話希望樓主能買「數據結構」之類的書，對提高邏輯以及C語言有很大的幫助！

這本書的編輯是「譚浩強」教授，是中國響當當的人物，開始我也認為排序不好，但最後發現前面的每一個字都具有非凡的意義！~

你說的那個程序數太大了，我給改為1*2*3*....*10結果：如圖

樓主還是要認真的讀讀那本書，我也不知道更好的辦法了！

㈤ c語言演算法具體步驟

不知道你要問什麼：
第一個程序，如果你要計數，比如，想得到結果為2，2，2，2，那麼你在switch中，每個case後要加break；
第二個程序的結論不對，應該是0,1，2 1 2 3； 2，3, 4
第三個程序，結論是正確的，static變數放在內存全局區域，會自動初始化為0，然後實現的是矩陣賦值，再轉置，最後輸出

㈥ 求A* 演算法C語言源程序

#include <string.h>
#include <stdio.h>
#include <malloc.h>
#include <time.h>
#define NULL 0

const int nmax = 200;
const int nend = 99; /*終點坐標的代表點*/
static char achar[10][10];
static int npayo = 0; /*0 表示空 1為非空*/
static int npayc = 0; /*0 表示空 1為非空*/
static int npay_x = 0; /*起點*/
static int npay_y = 0;
static int nend_x = 9; /*終點*/
static int nend_y = 9;
static int nnewpay_x;
static int nnewpay_y;
static int ndian = 101;
static int nh;
static long i = 10000000L;

struct Spaydian
{
int ng;
int nf; /*路徑評分*/
int nmy_x; /*自己位置*/
int nmy_y;
int nfatherx; /*父節點*/
int nfathery;
int nflag; /* 0 wei O; 1 wei @ */
};
static struct Spaydian spaydian[200];

/* open close list 表 */
typedef struct spaylist
{
int n_f;
int n_x;
int n_y;
int nfather_x;
int nfather_y;
struct spaylist *next;
};
static struct spaylist *open_list, *close_list;

static void smline();
static int sjudge(int nx,int ny,int i); /*判斷在第nx列ny行向第i個方向走是否可以,可以返回1否則返回0。
i=1表示向右，2表示向下，3表示向左，4表示向上*/
static void spath();
static void spayshow(int nxx,int nyy);
static int sifopen( int nx,int ny); /*判斷點是否在 open 表上*/
static int sifclose(int nx,int ny); /*判斷點是否在 close 表上*/
static int snewx(int nx,int i);
static int snewy(int ny,int i);
static spaylist *creat(); /*建立鏈表*/
static spaylist *del(spaylist *head,int num_x,int num_y); /*刪除鏈表的結點*/
static spaylist *snewdianx(spaylist *head);/*新的點*/
static spaylist *snewdiany(spaylist *head);
static spaylist *insert(spaylist *head,int ndian); /* 點插入鏈表 */
static spaylist *srebirth(spaylist *head,int ndian); /*更新表*/

int main()
{
FILE *fp ;
char ach ;
int ni = 0 ; /*統計個數*/
int nii = 0; /*achar[nii][njj]*/
int njj = 0;
if ((fp=fopen("route.txt","rt")) == NULL) /* 判斷打開文件是否為空 */
{
printf("文件為空！~\n");
return 0;
/* exit(1);*/
}
ach = fgetc(fp);
while(ach != EOF)
{
if(ach == 'O' || ach == '@') /*當值為@或O時候*/
{
spaydian[ni].ng = 0;
spaydian[ni].nf = nmax;
spaydian[ni].nmy_x = njj;
spaydian[ni].nmy_y = nii;
spaydian[ni].nfathery = -1;
spaydian[ni].nfatherx = -1;
if(ach == '@')
{
spaydian[ni].nflag = 1;
}
else if(ach == 'O')
{
spaydian[ni].nflag = 0;
}
ni++;
achar[nii][njj] = ach;
njj++;
if(njj == 10)
{
nii++;
njj = 0;
}
} /*end if*/
ach = fgetc(fp);
}/*end while*/
smline(); /* a*演算法 */
fp=fopen("answer.txt","w");
for(int i=0;i<10;i++ )
{ for(int j=0;j<10;j++ )
{
printf("%c",achar[i][j]);
if(j==9)
printf("\n");
fprintf(fp,"%c",achar[i][j]);
if (j==9)
fprintf(fp,"\n");
}
}
fclose(fp);
return 0;
}

/* a* 演算法 */
static void smline()
{ close_list = open_list = NULL;
open_list = creat();
while(open_list != NULL) /* 當open 表不為空時 */
{
open_list = del(open_list,npay_x,npay_y); /*刪除open 鏈表的結點*/
if(npay_x == 9 && npay_y == 9)
{

achar[9][9] = '=';
spath(); /*尋找並畫出路徑*/
break;
}
for (int i=1; i<=4; i++) /*四個方向逐個行走，i=1向右 2向下 3向左 4向上*/
{
if (sjudge(npay_x,npay_y,i))
{

nnewpay_x = snewx(npay_x,i);
nnewpay_y = snewy(npay_y,i);
if(open_list != NULL)
npayo = sifopen(nnewpay_x,nnewpay_y) ; /*判斷點是否在 open 表中*/
else
npayo = 0;

if(close_list != NULL)
npayc = sifclose(nnewpay_x,nnewpay_y) ; /*判斷點是否在 close 表中*/
else
npayc = 0;
ndian = 10*nnewpay_x+nnewpay_y ;

if (npayo == 0 && npayc == 0 ) /*點不在open表也不在close表中*/
{
spaydian[ndian].ng = spaydian[10*npay_x+npay_y].ng + 1; /*更新點的基本信息*/
nh = (nend - ndian)/10 + (nend - ndian)%10 ;
spaydian[ndian].nf = spaydian[ndian].ng+nh;
spaydian[ndian].nfathery = npay_y;
spaydian[ndian].nfatherx = npay_x;
spaydian[ndian].nmy_y = nnewpay_y;
spaydian[ndian].nmy_x = nnewpay_x;

open_list = insert(open_list,ndian);/*點插入open 表中*/
}
else if (npayo == 1) /*點在open表中*/
{
spaydian[ndian].ng = spaydian[10*npay_x+npay_y].ng + 1;
nh = (nend - ndian)/10 + (nend - ndian)%10 ;
if(spaydian[ndian].nf > (spaydian[ndian].ng+nh) && spaydian[ndian].nf != nmax)
{
spaydian[ndian].nf = spaydian[ndian].ng+nh;
open_list = srebirth(open_list,ndian); /*點插入open 表中*/
}
}
else if(npayc == 1) /*新生成的點在close表中*/
{
spaydian[ndian].ng = spaydian[10*npay_x+npay_y].ng + 1;
nh = (nend - ndian)/10 + (nend - ndian)%10 ;
if(spaydian[ndian].nf > (spaydian[ndian].ng+nh) && spaydian[ndian].nf != nmax)
{
spaydian[ndian].nf = spaydian[ndian].ng+nh;
close_list = srebirth(close_list,ndian);
close_list = del(close_list,nnewpay_x,nnewpay_y); /*刪除close鏈表的結點*/
open_list = insert(open_list,ndian);/*點插入open 表中*/
}
}/*end else if*/
}/*end if*/
}/*end for*/
close_list = insert(close_list,(10*npay_x+npay_y));/*點插入close 表中*/
if(open_list != NULL)
{
npay_x = open_list->n_x;
npay_y = open_list->n_y;
}

}/*end while*/
if(open_list == NULL)
{printf("無路可走 \n");}
}

/*建立鏈表*/
spaylist *creat(void)
{
spaylist *head;
spaylist *p1;
int n=0;
p1=(spaylist*)malloc(sizeof(spaylist));
p1->n_f = 18;
p1->n_x = 0;
p1->n_y = 0;
p1->nfather_x = -1;
p1->nfather_x = -1;
p1->next = NULL;
head = NULL;
head=p1;
return(head);
}

/*刪除結點*/
spaylist *del(spaylist *head,int num_x,int num_y)
{
spaylist *p1, *p2;
if(head == NULL)
{
printf("\nlist null!\n");
return (head);
}
p1 = head;
while((num_y != p1->n_y ||num_x != p1->n_x )&& p1->next != NULL)
{
p2=p1;
p1=p1->next;
}
if(num_x == p1->n_x && num_y == p1->n_y )
{
if(p1==head)
head=p1->next;
else
p2->next=p1->next;
}

return (head);
}

/*輸出*/
static void spath()
{
int nxx;
int nyy;
nxx = spaydian[nend].nfatherx;
nyy = spaydian[nend].nfathery;

spayshow(nxx,nyy) ;
}

/*遞歸*/
void spayshow(int nxx,int nyy)
{ achar[nxx][nyy] = '=';
if( nxx != 0 || nyy != 0 )
{
int nxxyy = 10*nxx+nyy;
nxx = spaydian[nxxyy].nfatherx;
nyy = spaydian[nxxyy].nfathery;
spayshow(nxx,nyy);
}
}

/* 判斷周圍四個點是否可行 */
static int sjudge(int nx,int ny,int i)
{
if (i==1) /*判斷向右可否行走*/
{
if (achar[nx][ny+1]=='O' && ny<9)
{
return 1;
}
else
return 0;
}
else if (i==2) /*判斷向下可否行走*/
{
if (achar[nx+1][ny]=='O' && nx<9)
{
return 1;
}
else
return 0;
}
else if (i==3)/*判斷向左可否行走 */
{
if (ny > 0&&achar[nx][ny-1]=='O')
{
return 1;
}
else
return 0;
}
else if (i==4)/*判斷向上可否行走 */
{
if (nx > 0&&achar[nx-1][ny]=='O')
{
return 1;
}
else
return 0;
}
else
return 0;
}

/* 求新的x點 */
static int snewx(int nx,int i)
{
if(i == 1)
nx = nx;
else if(i == 2)
nx = nx+1;
else if(i == 3)
nx = nx;
else if(i == 4)
nx = nx-1;
return nx;
}
/* 求新的y點 */
static int snewy(int ny, int i)
{
if(i == 1)
ny = ny+1;
else if(i == 2)
ny = ny;
else if(i == 3)
ny = ny-1;
else if(i == 4)
ny = ny;
return ny;
}

/*判定點是否在open表中*/
int sifopen(int nx,int ny)
{
spaylist *p1, *p2;
p1 = open_list;
while((ny != p1->n_y || nx != p1->n_x )&& p1->next != NULL)
{
p2 = p1;
p1 = p1->next;
}
if(nx == p1->n_x && ny == p1->n_y)
return 1;
else
return 0;
}

/*判定點是否在close表中*/
int sifclose(int nx,int ny)
{

spaylist *p1, *p2;
p1 = close_list;
while((ny != p1->n_y ||nx != p1->n_x )&& p1->next != NULL)
{
p2=p1;
p1=p1->next;
}
if(nx == p1->n_x && ny == p1->n_y)
return 1;
else
return 0;
}

/*插入結點*/
spaylist * insert(spaylist *head,int ndian)
{
spaylist *p0,*p1,*p2;
p1=head;
p0=(spaylist*)malloc(sizeof(spaylist));
p0->n_f = spaydian[ndian].nf;
p0->n_x = spaydian[ndian].nmy_x;
p0->n_y = spaydian[ndian].nmy_y;
p0->nfather_x = spaydian[ndian].nfatherx;
p0->nfather_x = spaydian[ndian].nfathery;
p0->next = NULL;
if(head==NULL)
{
head=p0;
p0->next=NULL;
}
else
{
while((p0->n_f > p1->n_f)&&(p1->next!=NULL))
{
p2=p1;
p1=p1->next;
}
if(p0->n_f <= p1->n_f)
{
if(head==p1)
head=p0;
else
p2->next=p0;
p0->next=p1;
}
else
{
p1->next=p0;
p0->next=NULL;
}
}
return (head);
}

/* 更新鏈表 */
spaylist * srebirth(spaylist *head,int ndian)
{
spaylist *p1, *p2;
p1=head;
while(spaydian[ndian].nmy_x!=p1->n_x&&spaydian[ndian].nmy_x!=p1->n_x&&p1->next!=NULL)
{
p2=p1;
p1=p1->next;
}
if(spaydian[ndian].nmy_x==p1->n_x&&spaydian[ndian].nmy_x==p1->n_x)
{
p1->n_f = spaydian[ndian].nf;
}
return (head);
}

㈦ c語言演算法

離散數學離散數學作為計算機學科的基礎是競賽中涉及最多的數學分支，重中之重又在於圖論和組合數學，尤其是圖論。圖論之所以運用最多是因為它的變化最多，而且可以輕易地結合基本數據結構和許多演算法的基本思想，較多用到的知識包括連通性判斷、DFS和BFS，關節點和關鍵路徑、歐拉迴路、最小生成樹、最短路徑、二部圖匹配和網路流等等。雖然這部分的比重很大，但是往往也是競賽中的難題所在，如果有初學者對於這部分的某些具體內容暫時感到力不從心，也不必著急，可以慢慢積累。組合數學競賽中設計的組合計數問題大都需要用組合數學來解決，組合數學中的知識相比於圖論要簡單一些，很多知識對於小學上過奧校的同學來說已經十分熟悉，但是也有一些部分需要先對代數結構中的群論有初步了解才能進行學習。組合數學在競賽中很少以難題的形式出現，但是如果積累不夠，任何一道這方面的題目卻都有可能成為難題。數論以素數判斷和同餘為模型構造出來的題目往往需要較多的數論知識來解決，這部分在競賽中的比重並不大，但只要來上一道，也足以使知識不足的人冥思苦想上一陣時間。素數判斷和同餘最常見的是在以密碼學為背景的題目中出現，在運用密碼學常識確定大概的過程之後，核心演算法往往要涉及數論的內容。計算幾何計算幾何相比於其它部分來說是比較獨立的，就是說它和其它的知識點很少有過多的結合，較常用到的部分包括—線段相交的判斷、多邊形面積的計算、內點外點的判斷、凸包等等。計算幾何的題目難度不會很大，但也永遠不會成為最弱的題。線性代數對線性代數的應用都是圍繞矩陣展開的，一些表面上是模擬的題目往往可以藉助於矩陣來找到更好的演算法。 ~

㈧ c語言中什麼是演算法有哪些描述演算法的例子

1、有窮性（有限性）。任何一種提出的解題方法都是在有限的操作步驟內可以完成的。
如果在有限的操作步驟內完不成，得不到結果，這樣的演算法將無限的執行下去，永遠不會停止。除非手動停止。例如操作系統就不具有有窮性，它可以一直運行。
2、一個演算法應該具有以下七個重要的特徵：
1）有窮性（finiteness）
演算法的有窮性是指演算法必須能在執行有限個步驟之後終止
2）確切性(definiteness)
演算法的每一步驟必須有確切的定義；
3）輸入項(input)
一個演算法有0個或多個輸入,以刻畫運算對象的初始情況,所謂0個輸入是指演算法本身定出了初始條件；
4）輸出項(output)
一個演算法有一個或多個輸出,以反映對輸入數據加工後的結果.沒有輸出的演算法是毫無意義的；
5）可行性(effectiveness)
演算法中執行的任何計算步都是可以被分解為基本的可執行的操作步,即每個計算步都可以在有限時間內完成；
6）
高效性（high
efficiency）
執行速度快,佔用資源少；
7）
健壯性（robustness）
健壯性又稱魯棒性，是指軟體對於規范要求以外的輸入情況的處理能力。所謂健壯的系統是指對於規范要求以外的輸入能夠判斷出這個輸入不符合規范要求，並能有合理的處理方式。