算法代码有哪些

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;

}