演算法代碼有哪些

A. matlab遺傳演算法代碼

我發一些他們的源程序你，都是我在文獻中搜索總結出來的：
% 下面舉例說明遺傳演算法 %
% 求下列函數的最大值 %
% f(x)=10*sin(5x)+7*cos(4x) x∈[0,10] %
% 將 x 的值用一個10位的二值形式表示為二值問題，一個10位的二值數提供的解析度是每為 (10-0)/(2^10-1)≈0.01 。 %
% 將變數域 [0,10] 離散化為二值域 [0,1023], x=0+10*b/1023, 其中 b 是 [0,1023] 中的一個二值數。 %
% %
%--------------------------------------------------------------------------------------------------------------%
%--------------------------------------------------------------------------------------------------------------%

% 編程
%-----------------------------------------------
% 2.1初始化(編碼)
% initpop.m函數的功能是實現群體的初始化，popsize表示群體的大小，chromlength表示染色體的長度(二值數的長度)，
% 長度大小取決於變數的二進制編碼的長度(在本例中取10位)。
%遺傳演算法子程序
%Name: initpop.m
%初始化
function pop=initpop(popsize,chromlength)
pop=round(rand(popsize,chromlength)); % rand隨機產生每個單元為 {0,1} 行數為popsize，列數為chromlength的矩陣，
% roud對矩陣的每個單元進行圓整。這樣產生的初始種群。

% 2.2.2 將二進制編碼轉化為十進制數(2)
% decodechrom.m函數的功能是將染色體(或二進制編碼)轉換為十進制，參數spoint表示待解碼的二進制串的起始位置
% (對於多個變數而言，如有兩個變數，採用20為表示，每個變數10為，則第一個變數從1開始，另一個變數從11開始。本例為1)，
% 參數1ength表示所截取的長度（本例為10）。
%遺傳演算法子程序
%Name: decodechrom.m
%將二進制編碼轉換成十進制
function pop2=decodechrom(pop,spoint,length)
pop1=pop(:,spoint:spoint+length-1);
pop2=decodebinary(pop1);

% 2.4 選擇復制
% 選擇或復制操作是決定哪些個體可以進入下一代。程序中採用賭輪盤選擇法選擇，這種方法較易實現。
% 根據方程 pi=fi/∑fi=fi/fsum ，選擇步驟：
% 1） 在第 t 代，由（1）式計算 fsum 和 pi
% 2） 產生 {0,1} 的隨機數 rand( .)，求 s=rand( .)*fsum
% 3） 求 ∑fi≥s 中最小的 k ，則第 k 個個體被選中
% 4） 進行 N 次2）、3）操作，得到 N 個個體，成為第 t=t+1 代種群
%遺傳演算法子程序
%Name: selection.m
%選擇復制
function [newpop]=selection(pop,fitvalue)
totalfit=sum(fitvalue); %求適應值之和
fitvalue=fitvalue/totalfit; %單個個體被選擇的概率
fitvalue=cumsum(fitvalue); %如 fitvalue=[1 2 3 4]，則 cumsum(fitvalue)=[1 3 6 10]
[px,py]=size(pop);
ms=sort(rand(px,1)); %從小到大排列
fitin=1;
newin=1;
while newin<=px
if(ms(newin))<fitvalue(fitin)
newpop(newin)=pop(fitin);
newin=newin+1;
else
fitin=fitin+1;
end
end

% 2.5 交叉
% 交叉(crossover)，群體中的每個個體之間都以一定的概率 pc 交叉，即兩個個體從各自字元串的某一位置
% （一般是隨機確定）開始互相交換，這類似生物進化過程中的基因分裂與重組。例如，假設2個父代個體x1，x2為：
% x1=0100110
% x2=1010001
% 從每個個體的第3位開始交叉，交又後得到2個新的子代個體y1，y2分別為：
% y1＝0100001
% y2＝1010110
% 這樣2個子代個體就分別具有了2個父代個體的某些特徵。利用交又我們有可能由父代個體在子代組合成具有更高適合度的個體。
% 事實上交又是遺傳演算法區別於其它傳統優化方法的主要特點之一。
%遺傳演算法子程序
%Name: crossover.m
%交叉
function [newpop]=crossover(pop,pc)
[px,py]=size(pop);
newpop=ones(size(pop));
for i=1:2:px-1
if(rand<pc)
cpoint=round(rand*py);
newpop(i,:)=[pop(i,1:cpoint),pop(i+1,cpoint+1:py)];
newpop(i+1,:)=[pop(i+1,1:cpoint),pop(i,cpoint+1:py)];
else
newpop(i,:)=pop(i);
newpop(i+1,:)=pop(i+1);
end
end

% 2.6 變異
% 變異(mutation)，基因的突變普遍存在於生物的進化過程中。變異是指父代中的每個個體的每一位都以概率 pm 翻轉，即由「1」變為「0」，
% 或由「0」變為「1」。遺傳演算法的變異特性可以使求解過程隨機地搜索到解可能存在的整個空間，因此可以在一定程度上求得全局最優解。
%遺傳演算法子程序
%Name: mutation.m
%變異
function [newpop]=mutation(pop,pm)
[px,py]=size(pop);
newpop=ones(size(pop));
for i=1:px
if(rand<pm)
mpoint=round(rand*py);
if mpoint<=0
mpoint=1;
end
newpop(i)=pop(i);
if any(newpop(i,mpoint))==0
newpop(i,mpoint)=1;
else
newpop(i,mpoint)=0;
end
else
newpop(i)=pop(i);
end
end

很多哈，也很麻煩，但是設計程序就是如此！得耐心點才行。 最近又作了些總結，要有興趣網路HI我吧。我有M文件，運行成功

B. 求幾個演算法的c程序代碼~~~~~~!

主要是太難了,年紀大了,懶得想復雜的事了.

最速下降法,
http://www..com/s?wd=%D7%EE%CB%D9%CF%C2%BD%B5%B7%A8&cl=3

網上有很多這樣的資料,如果你想看書,可以查看演算法方面的書,一般的演算法書還沒有呢.你是大學生嗎？可以上圖書館查查。

C. kmp演算法完整代碼（C++）謝謝！

#include"stdio.h"
#include "conio.h"
#include "stdio.h"
#include "math.h"

int result;
char pat[]="kaka";
char str[]="iamkaka";
int next[7];

void getNext(char pat[], int next[])
{
int j = 0;
int k = -1;
next[0] = -1;
while (pat[j])
{
if ( k == -1 || pat[j] == pat[k])
{
j++;
k++;
next[j] = k;
}
else
{
k = next[k];
}
}
}
int KMP(char *str1, char*pat, int *next)
{
int i=0,j=0;
while(str[i])
{
if(pat[j]==0)
return i-j;
if(j==0 || str[i]==pat[j])
{
++i;
++j;
}else
j=next[j];
}
if(pat[j]==0)
return i-j;
return -1;
}

int main(int argc, char* argv[])
{
int i;

getNext(pat,next);
result=KMP(str,pat,next);
printf("%s\n",str);
for(i=0;i<result;i++) printf(" ");
printf("%s\n",pat);
printf("at %d\n",result);
getch();
return 0;
}

這個演算法有點難理解的
Dev-C++ 編譯測試通過：
結果：
iamkaka
kaka
at 3
祝你好運！
這種題目考試有必殺技的。我用顏色標注了的，但是這里不能用顏色來講解NExt數組的變化。
有需要。給我留言！

D. 代碼演算法，有什麼樣的演算法或者數學公式實現下面這個功能

演算法簡述：

1、輸入總人數。

2、拿出A，每3人組一個局，累計局數。

3、然後將A每局用過的人分別加在BCD三組下，剩餘不足3人的人數記在賬上。

4、對BCD三組下的人數分別重復A的計算，計算時合並用上前道計算的剩餘人數。

5、使用遞歸過程對BCD下一級進行上述1到4的步驟。

6、總人數不足4人時退出遞歸。

以下是12人、100人、1000人、10000人的計算結果：

12人最多可以組5局。

以下分別是m=12，100，1000，10000時的計算結果，以及fortran代碼。

E. 請問有誰有計算機各種經典演算法的總結性介紹有源代碼最好

http://blog.csdn.net/ctu_85/archive/2008/05/11/2432736.aspx
上面的內容應有盡有，連代碼都給出了:
經典演算法設計方法大雜燴

經典演算法設計方法

一、什麼是演算法

演算法是一系列解決問題的清晰指令，也就是說，能夠對一定規范的輸入，在有限時間內獲得所要求的輸出。演算法常常含有重復的步驟和一些比較或邏輯判斷。如果一個演算法有缺陷，或不適合於某個問題，執行這個演算法將不會解決這個問題。不同的演算法可能用不同的時間、空間或效率來完成同樣的任務。一個演算法的優劣可以用空間復雜度與時間復雜度來衡量。

演算法的時間復雜度是指演算法需要消耗的時間資源。一般來說，計算機演算法是問題規模n 的函數f(n)，演算法執行的時間的增長率與f(n) 的增長率正相關，稱作漸進時間復雜度（Asymptotic Time Complexity）。時間復雜度用「O（數量級）」來表示，稱為「階」。常見的時間復雜度有： O（1）常數階；O（log2n）對數階；O（n）線性階；O（n2）平方階。

演算法的空間復雜度是指演算法需要消耗的空間資源。其計算和表示方法與時間復雜度類似，一般都用復雜度的漸近性來表示。同時間復雜度相比，空間復雜度的分析要簡單得多。

二、演算法設計的方法

1.遞推法

遞推法是利用問題本身所具有的一種遞推關系求問題解的一種方法。設要求問題規模為N的解，當N=1時，解或為已知，或能非常方便地得到解。能採用遞推法構造演算法的問題有重要的遞推性質，即當得到問題規模為i-1的解後，由問題的遞推性質，能從已求得的規模為1，2，…，i-1的一系列解，構造出問題規模為I的解。這樣，程序可從i=0或i=1出發，重復地，由已知至i-1規模的解，通過遞推，獲得規模為i的解，直至得到規模為N的解。

【問題】 階乘計算

問題描述：編寫程序，對給定的n（n≤100），計算並輸出k的階乘k！（k=1，2，…，n）的全部有效數字。

由於要求的整數可能大大超出一般整數的位數，程序用一維數組存儲長整數，存儲長整數數組的每個元素只存儲長整數的一位數字。如有m位成整數N用數組a[ ]存儲：

N=a[m]×10m-1+a[m-1]×10m-2+ … +a[2]×101+a[1]×100

並用a[0]存儲長整數N的位數m，即a[0]=m。按上述約定，數組的每個元素存儲k的階乘k！的一位數字，並從低位到高位依次存於數組的第二個元素、第三個元素……。例如，5！=120，在數組中的存儲形式為：

3 0 2 1 ……

首元素3表示長整數是一個3位數，接著是低位到高位依次是0、2、1，表示成整數120。

計算階乘k！可採用對已求得的階乘(k-1)！連續累加k-1次後求得。例如，已知4！=24，計算5！，可對原來的24累加4次24後得到120。細節見以下程序代碼。

# include <stdio.h>

# include <malloc.h>

# define MAXN 1000

void pnext(int a[ ],int k)

{ int *b,m=a[0],i,j,r,carry;

b=(int * ) malloc(sizeof(int)* (m+1));

for ( i=1;i<=m;i++) b[i]=a[i];

for ( j=1;j<=k;j++)

{ for ( carry=0,i=1;i<=m;i++)

{ r=(i<a[0]?a[i]+b[i]:a[i])+carry;

a[i]=r%10;

carry=r/10;

}

if (carry) a[++m]=carry;

......

F. kruskal演算法的代碼實現

MST-KRUSKAL(G，w)
function Kruskal(w,MAX)
%此程序為最小支撐樹的Kruskal演算法實現
%w為無向圖的距離矩陣，故為對稱矩陣
%MAX為距離矩陣中∞的實際輸入值
%時間：2011年6月22日0:07:53
len=length(w); %圖的點數
edge=zeros(len*(len-1）,3）; %用於存儲圖中的邊
count=1; %圖中的邊數
for i=1:len-1 %循環距離矩陣，記錄存儲邊
for j=i+1:len
if w(i,j)~=MAX
edge(count,1）=w(i,j);
edge(count,2）=i;
edge(count,3）=j;
count=count+1;
end
end
end
edge=edge（1:count-1,:); %去掉無用邊
[tmp,index]=sort(edge(:,1）); %所有邊按升序排序
i=3; %其實測試邊數為3條（3條以下無法構成圈，即無需檢測）
while 1
x=findcycle(edge(index（1:i),:),len); %檢測這些邊是否構成圈
if x
index(i)=0; %若構成圈，則將該邊對應的index項標記為0，以便除去
else
i=i+1; %若沒有構成圈，則i加1，加入下一邊檢測
end
index=index(index>0); %將構成圈的邊從index中除去
if i==len
break; %找到符合條件的點數減一條的邊，即找到一個最小支撐樹
end
end
index=index（1:len-1）; %截短index矩陣，保留前len-1項
%%%%%%%%%%%% 結果顯示 %%%%%%%%%%%%%
s=sprintf(' %s %s %s ','邊端點','距離','是否在最小支撐樹');
for i=1:count-1
edge_tmp=edge(i,:);
if ~isempty(find(index==i,1）)
s_tmp=sprintf(' (%d,%d) %d %s ',edge_tmp（2）,edge_tmp（3）,edge_tmp（1）,'√');
else
s_tmp=sprintf(' (%d,%d) %d %s ',edge_tmp（2）,edge_tmp（3）,edge_tmp（1）,'×');
end
s=strcat(s,s_tmp);
end
disp(s);
end
function isfind=findcycle(w,N)
%本程序用於判斷所給的邊能否構成圈：有圈，返回1；否則返回0
%w：輸入的邊的矩陣
%N：原圖的點數
%原理：不斷除去出現次數小於2的端點所在的邊，最後觀察是否有邊留下
len=length(w(:,1）);
index=1:len;
while 1
num=length(index); %邊數
p=zeros（1,N); %用於存儲各點的出現的次數（一條邊對應兩個端點）
for i=1:num %統計各點的出現次數
p(w(index(i),2）)=p(w(index(i),2）)+1;
p(w(index(i),3）)=p(w(index(i),3）)+1;
end
index_tmp=zeros（1,num); %記錄除去出現次數小於2的端點所在的邊的邊的下標集合
discard=find(p<2）; %找到出現次數小於2的端點
count=0; %記錄剩餘的邊數
for i=1:num
%判斷各邊是否有僅出現一次端點——沒有，則記錄其序號於index_tmp
if ~(~isempty(find(discard==w(index(i),2）,1）) || ~isempty(find(discard==w(index(i),3）,1）))
count=count+1;
index_tmp(count)=index(i);
end
end
if num==count %當沒有邊被被除去時，循環停止
index=index_tmp（1:count); %更新index
break;
else
index=index_tmp（1:count); %更新index
end
end
if isempty(index) %若最後剩下的邊數為0，則無圈
isfind=0;
else
isfind=1;
end
end
%
% a =[
% 0 3 2 3 100 100 100
% 3 0 2 100 100 100 6
% 2 2 0 3 100 1 100
% 3 100 3 0 5 100 100
% 100 100 100 5 0 4 6
% 100 100 1 100 4 0 5
% 100 6 100 6 100 5 0];
%
% Kruskal(a,100） {
最小生成樹的Kruskal演算法。
Kruskal演算法基本思想：
每次選不屬於同一連通分量（保證不生成圈）且邊權值最小的頂點，將邊加入MST，並將所在的2個連通分量合並，直到只剩一個連通分量
排序使用Quicksort(O(eloge))
檢查是否在同一連通分量用Union-Find，每次Find和union運算近似常數
Union-Find使用rank啟發式合並和路徑壓縮
總復雜度O(eloge)=O(elogv) （因為e<n(n-1）/2）
} constmaxn=100;maxe=maxn*maxn;typeedge=recorda,b:integer;//邊的2個頂點len:integer;//邊的長度end;varedges:array[0..maxe]ofedge;//保存所有邊的信息p,r:array[0..maxn]ofinteger;//p保存i的父親節點，r用來實現Union-Find的rank啟發式n,e:integer;//n為頂點數，e為邊數procereswap(a,b:integer);//交換beginedges[0]:=edges[a];edges[a]:=edges[b];edges[b]:=edges[0];end;procerequicksort(l,r:integer);//快速排序varx,i,j:integer;beginx:=edges[random(r-l+1)+l].len;i:=l;j:=r;repeatwhileedges[i].len<xdoinc(i);whileedges[j].len>xdodec(j);ifi<=jthenbeginswap(i,j);inc(i);dec(j);enntili>j;ifl<jthenquicksort(l,j);ifi<rthenquicksort(i,r);end;procereinit;vari:integer;beginassign(input,'g.ini');reset(input);readln(n,e);fori:=1toedoreadln(edges[i].a,edges[i].b,edges[i].len);//從文件讀入圖的信息fori:=1tondop[i]:=i;//初始化並查集randomize;quicksort(1,e);//使用快速排序將邊按權值從小到大排列end;functionfind(x:integer):integer;//並查集的Find，用來判斷2個頂點是否屬於一個連通分量beginifx<>p[x]thenp[x]:=find(p[x]);find:=p[x]end;procereunion(a,b:integer);//如果不屬於且權值最小則將2個頂點合並到一個連通分量vart:integer;begina:=find(a);b:=find(b);ifr[a]>r[b]thenbegint:=a;a:=b;b:=tend;ifr[a]=r[b]theninc(r[a]);p[a]:=b;end;procerekruskal;//主過程varen:integer;//en為當前邊的編號count:integer;//統計進行了幾次合並。n-1次合並後就得到最小生成樹tot:integer;//統計最小生成樹的邊權總和begincount:=0;en:=0;tot:=0;whilecount<n-1dobegininc(en);withedges[en]dobeginiffind(a)<>find(b)thenbeginunion(a,b);writeln(a,'--',b,':',len);inc(tot,len);inc(count);end;end;end;writeln('TotalLength=',tot)end;{===========main==========}begininit;kruskal;end.Kruskal演算法適用於邊稀疏的情形，而Prim演算法適用於邊稠密的情形 importjava.util.ArrayList;importjava.util.Collections;classBianimplementsComparable//兩點之間的加權邊{privateintfirst,second;//表示一條邊的兩個節點privateintvalue;//權值publicBian(intfirst,intsecond,intvalue){this.first=first;this.second=second;this.value=value;}publicintgetFirst(){returnfirst;}publicintgetSecond(){returnsecond;}publicintgetValue(){returnvalue;}@OverridepublicintcompareTo(Objectarg0){returnvalue>((Bian)arg0).value1:(value==((Bian)arg0).value0:-1）;}@OverridepublicStringtoString(){returnBian[first=+first+,second=+second+,value=+value+];}}classShuZu{staticArrayList<ArrayList>list=newArrayList<ArrayList>();//存放每一個數組中的節點的數組staticArrayList<ArrayList>bianList=newArrayList<ArrayList>();//對應存放數組中的邊的數組publicstaticvoidcheck(Bianb)//檢查在哪個數組中{if(list.size()==0){ArrayList<Integer>sub=newArrayList<Integer>();sub.add(b.getFirst());sub.add(b.getSecond());list.add(sub);ArrayList<Bian>bian=newArrayList<Bian>();bian.add(b);bianList.add(bian);return;}intfirst=b.getFirst();intshuyu1=-1;intsecond=b.getSecond();intshuyu2=-1;for(inti=0;i<list.size();i++)//檢查兩個節點分別屬於哪個數組{for(intm=0;m<list.get(i).size();m++){if(first==(Integer)list.get(i).get(m))shuyu1=i;if(second==(Integer)list.get(i).get(m))shuyu2=i;}}if(shuyu1==-1&&shuyu2==-1）//表示這兩個節點都沒有需要新加入{ArrayList<Integer>sub=newArrayList<Integer>();sub.add(b.getFirst());sub.add(b.getSecond());list.add(sub);ArrayList<Bian>bian=newArrayList<Bian>();bian.add(b);bianList.add(bian);}if(shuyu1==-1&&shuyu2!=-1）//表示有一個點已經在數組中只把另一個加入就可以了{list.get(shuyu2).add(first);bianList.get(shuyu2）.add(b);}if(shuyu2==-1&&shuyu1!=-1）//表示有一個點已經在數組中只把另一個加入就可以了{list.get(shuyu1).add(second);bianList.get(shuyu1).add(b);}if(shuyu1==shuyu2&&shuyu1!=-1）//表述兩個在同一個組中會形成環{}if(shuyu1!=shuyu2&&shuyu1!=-1&&shuyu2!=-1）//表示兩個點在不同的組中需要合並{for(inti=0;i<list.get(shuyu2）.size();i++){list.get(shuyu1）.add(list.get(shuyu2）.get(i));}list.remove(shuyu2）;for(inti=0;i<bianList.get(shuyu2）.size();i++){bianList.get(shuyu1）.add(bianList.get(shuyu2）.get(i));}bianList.get(shuyu1）.add(b);bianList.remove(shuyu2）;}}publicstaticvoidshow(){for(inti=0;i<bianList.get(0).size();i++)System.out.println(bianList.get(0).get(i));}}publicclassTest{publicstaticvoidmain(String[]args){ArrayList<Bian>l=newArrayList<Bian>();l.add(newBian（1,3,1）);l.add(newBian（1,2,6）);l.add(newBian（1,4,5）);l.add(newBian（2,3,5）);l.add(newBian（2,5,3）);l.add(newBian（3,4,5）);l.add(newBian（3,5,6）);l.add(newBian（3,6,4）);l.add(newBian（4,6,2）);l.add(newBian（5,6,6）);Collections.sort(l);//for(inti=0;i<l.size();i++)//System.out.println(l.get(i));for(inti=0;i<l.size();i++)ShuZu.check(l.get(i));ShuZu.show();}}

G. C語言中最基本的用計算機語言表示演算法的代碼有哪些並解釋一下

（一）「項目驅動」式教學 目前最著名、最有影響、應用最廣泛的windows、linux和UNIX三個操作系統都是用C語言編寫的。0S是計算機系統(由軟硬體兩個子系統構成)的核心和靈魂，它是軟體中最龐大最復雜的系統軟體。既然如此龐大復雜的0S都可以用c語言編寫，從狹義而言，還...

H. 求c語言 演算法 求大神的代碼

說白了這道題是數學題，首先要知道位數越多，值越大，那麼也就是說在兩個加號之間的位數越小，值就越小。
假設串的長度為size
那麼1:如果M+1被串的長度整除，這個最簡單，直接把這個串平分分成M+1分，在中間加入+號，也就是在size/(M+1)+(size/(M+1)+1)*i, i=0,1,2...處插入加號
但是不是所有的M+1都能被size整除，在不能被整除的情況下，先算出size/(M+1)的值，假設等於m1，再算出size%M的值，假設等於m2.這時候這個算式得到一個值，這種情況初始就是把加號加在m1+(m1+1)*i處，
for(j=0,j<m2,++j)
{
找出最小的一個數，將該數右邊的加號依次右移一位}
大致邏輯應該是這樣的吧

I. 求一個C++演算法代碼

這段代碼我寫的有點長,而且變數用的也多,可以優化,不過我沒有時間,你要是覺得可以就用吧,我沒加註釋,也不好注釋,大體思路是用帶頭節點鏈表的單鏈表,因為你最後需要有組合,所以這樣做了,程序運行應該比較好用,看到屏幕不動是需要按任意鍵
請用VC6.0以上的編譯器編譯,如果不滿意可以補充
#include <iostream.h>
#include <conio.h>
#define MIN1 1
#define MAX1 10
#define MIN2 11
#define MAX2 20
typedef struct lnode{
int data;struct lnode *next;
}lnode,*link;
typedef struct xlnode{
link row;struct xlnode *col;
}xlnode,*xlink;
void fun(int n,int m,int min,int max,xlink &p,link &q)
{
link r,s;xlink t;
if((n!=1)&&(n!=m)){
s=q;
r=new lnode;r->data=min;r->next=NULL;
for(int i=m-n-1;i>0;i--)s=s->next;
s->next=r;
for(i=min;i<=max-n+1;i++)
fun(n-1,m,i+1,max,p,q);
}
if(n==m)
for(int j=min;j<=max-n+1;j++){
r=new lnode;r->data=j;r->next=NULL;q=r;p->row=r;
for(int i=j+1;i<=max-n+2;i++)
fun(n-1,m,i,max,p,q);
}
if(n==1){
link xr;
s=q;while(s->next)s=s->next;
r=new lnode;r->data=min;r->next=NULL;
s->next=r;
t=new xlnode;t->col=NULL;
p->col=t;
s=q;r=new lnode;r->data=s->data;r->next=NULL;
t->row=r;xr=r;s=s->next;
while(s->next){
r=new lnode;r->data=s->data;r->next=NULL;
xr->next=r;xr=r;s=s->next;
}q=t->row;p=t;
}
}
void main()
{
int n,m,count;xlink p1,p2,xp1,xp2;link q1,q2,xq1,xq2;
p1=new xlnode;p2=new xlnode;
p1->col=NULL;p1->row=NULL;
p2->col=NULL;p2->row=NULL;
cout<<"輸入在區間"<<MIN1<<"到"<<MAX1<<"抽取數字個數:";
cin>>n;
m=n;xp1=p1;
fun(n,m,MIN1,MAX1,xp1,q1);
xp1=p1;count=0;
while(xp1->col){ xq1=xp1->row;
while(xq1){
cout<<xq1->data<<" ";xq1=xq1->next;}
count++;cout<<" ";if(count==5) {cout<<endl;count=0;}
xp1=xp1->col;
}getch();
cout<<"輸入在區間"<<MIN2<<"到"<<MAX2<<"抽取數字個數:";
cin>>n;xp2=p2;
fun(n,m,MIN2,MAX2,xp2,q2);
xp2=p2;count=0;
while(xp2->col){xq2=xp2->row;
while(xq2){
cout<<xq2->data<<" ";xq2=xq2->next;}
count++;cout<<" ";if(count==5) {cout<<endl;count=0;}
xp2=xp2->col;
}getch();
cout<<"組合後結果:"<<endl;
xp1=p1;xp2=p2;count=0;
while(xp1->col){xq1=xp1->row;
while(xp2->col){xq2=xp2->row;
while(xq1){cout<<xq1->data<<" ";xq1=xq1->next;}
while(xq2){cout<<xq2->data<<" ";xq2=xq2->next;}
count++;cout<<" ";if(!(count%3)) {cout<<endl;if(!(count%30))getch();}xq1=xp1->row;xp2=xp2->col;}
xp2=p2->col;xq2=xp2->row;xp1=xp1->col;}
getch();
}

J. c語言必背代碼有哪些

1、/*輸出9*9口訣。共9行9列，i控制行，j控制列。*/

#include "stdio.h"

main()

{int i,j,result;

for (i=1;i<10;i++)

{ for(j=1;j<10;j++)

{

result=i*j;

printf("%d*%d=%-3d",i,j,result);/*-3d表示左對齊，佔3位*/

}

printf(" ");/*每一行後換行*/

}

}

5、/*下面程序的功能是將一個4×4的數組進行逆時針旋轉90度後輸出，要求原始數組的數據隨機輸入，新數組以4行4列的方式輸出，

請在空白處完善程序。*/

main()

{ int a[4][4],b[4][4],i,j; /*a存放原始數組數據，b存放旋轉後數組數據*/

printf("input 16 numbers: ");

/*輸入一組數據存放到數組a中，然後旋轉存放到b數組中*/

for(i=0;i<4;i++)

for(j=0;j<4;j++)

{ scanf("%d",&a[i][j]);

b[3-j][i]=a[i][j];

}

printf("array b: ");

for(i=0;i<4;i++)

{ for(j=0;j<4;j++)

printf("%6d",b[i][j]);

printf(" ");

}

}

6、/*編程列印直角楊輝三角形*/

main()

{int i,j,a[6][6];

for(i=0;i<=5;i++)

{a[i][i]=1;a[i][0]=1;}

for(i=2;i<=5;i++)

for(j=1;j<=i-1;j++)

a[i][j]=a[i-1][j]+a[i-1][j-1];

for(i=0;i<=5;i++)

{for(j=0;j<=i;j++)

printf("%4d",a[i][j]);

printf(" ");}

}

7、/*通過鍵盤輸入3名學生4門課程的成績，

分別求每個學生的平均成績和每門課程的平均成績。

要求所有成績均放入一個4行5列的數組中，輸入時同一人數據間用空格,不同人用回車

其中最後一列和最後一行分別放每個學生的平均成績、每門課程的平均成績及班級總平均分。*/

#include <stdio.h>

#include <stdlib.h>

main()

{ float a[4][5],sum1,sum2;

int i,j;

for(i=0;i<3;i++)

for(j=0;j<4;j++)

scanf("%f",&a[i][j]);

for(i=0;i<3;i++)

{ sum1=0;

for(j=0;j<4;j++)

sum1+=a[i][j];

a[i][4]=sum1/4;

}