正文
java组卷算法代码,java堆排序算法代码
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
基于遗传算法的自动组卷系统的设计与实现（毕业设计） 求大神给一个系统
代码如下：
public class Problem
{
public Problem()
{
ID = 0;
Type = 0;
Score = 0;
Difficulty = 0.00;
Points = new Listint();
}
public Problem(Problem p)
{
this.ID = p.ID;
this.Type = p.Type;
this.Score = p.Score;
this.Difficulty = p.Difficulty;
this.Points = p.Points;
}
/// summary
/// 编号
/// /summary
public int ID { get; set; }
/// summary
/// 题型（1、2、3、4、5对应单选，多选，判断，填空，问答）
/// /summary
public int Type { get; set; }
/// summary
/// 分数
/// /summary
public int Score { get; set; }
/// summary
/// 难度系数
/// /summary
public double Difficulty { get; set; }
/// summary
/// 知识点
/// /summary
public Listint Points { get; set; }
}
相关问答
Q1: 一道java算法题提供了正确代码，不知道是不是我理解错误运行结果并不是最大值？
首先理解下题意，关键是连续的子数组，比如{1，2，-1} ，连续的子数组包括{1}、{2}、{-1}、{1，2}、{2，-1}、{1，2，-1}
其次是求各子数组和的最大值，上面的算法求最大值分两部分，循环遍历所有值
curSum ：用于某一个子数组的累加和
curMaxSum：用于记录历史最大累加和
上面算法的start和end其实没用，本意是找出具体子数组，但上面算法部分情况下是无法实现的
@Test
public void test(){
// int[] num = {1,-2,3,10,-4,7,2,-5};
//int[] num = {1,-2,3,10,-4,10,2,-5};
int[] num = {-1,-2,3,4,-5,-6,-7};
System.out.println(maxSum(num));
}
public int maxSum(int[] num){
int curSum = 0;
int curMaxSum = -99999999;
int finalStart = 0;
int finalEnd = 0;
int start = 0;
for(int i=0;inum.length;i++){
if(curSum=0){
curSum = num[i];
start = i;
}
else{
curSum += num[i];
}
if(curSumcurMaxSum){
finalStart = start;
finalEnd = i;
curMaxSum = curSum;
}
}
for(int i = finalStart;i=finalEnd;i++){
System.out.println(num[i]);
}
return curMaxSum;
}
Q2: 跪求java实现B/S考试系统的思路(最好有源代码)
做这个题库系统需要按照mvc设计一下, 最近我也实现一个类似的, 下面说下我的设计
数据库mysql+开发环境eclipse+jdk1.8, 然后基于一个整合框架把项目搭建起来
设计基础试题表, 这个主要有类型难度等等
设计试卷表, 试卷表由create的时候根据输入的规则自动根据上面的基础题库表组装而成
剩下的用户管理, 导出就比较容易了, 导出可以用poi导出成word
Q3: 如何用70行Java代码实现神经网络算法
如何用70行Java代码实现神经网络算法
import java.util.Random;
public class BpDeep{
public double[][] layer;//神经网络各层节点
public double[][] layerErr;//神经网络各节点误差
public double[][][] layer_weight;//各层节点权重
public double[][][] layer_weight_delta;//各层节点权重动量
public double mobp;//动量系数
public double rate;//学习系数
public BpDeep(int[] layernum, double rate, double mobp){
this.mobp = mobp;
this.rate = rate;
layer = new double[layernum.length][];
layerErr = new double[layernum.length][];
layer_weight = new double[layernum.length][][];
layer_weight_delta = new double[layernum.length][][];
Random random = new Random();
for(int l=0;llayernum.length;l++){
layer[l]=new double[layernum[l]];
layerErr[l]=new double[layernum[l]];
if(l+1layernum.length){
layer_weight[l]=new double[layernum[l]+1][layernum[l+1]];
layer_weight_delta[l]=new double[layernum[l]+1][layernum[l+1]];
for(int j=0;jlayernum[l]+1;j++)
for(int i=0;ilayernum[l+1];i++)
layer_weight[l][j][i]=random.nextDouble();//随机初始化权重
}
}
}
//逐层向前计算输出
public double[] computeOut(double[] in){
for(int l=1;llayer.length;l++){
for(int j=0;jlayer[l].length;j++){
double z=layer_weight[l-1][layer[l-1].length][j];
for(int i=0;ilayer[l-1].length;i++){
layer[l-1][i]=l==1?in[i]:layer[l-1][i];
z+=layer_weight[l-1][i][j]*layer[l-1][i];
}
layer[l][j]=1/(1+Math.exp(-z));
}
}
return layer[layer.length-1];
}
//逐层反向计算误差并修改权重
public void updateWeight(double[] tar){
int l=layer.length-1;
for(int j=0;jlayerErr[l].length;j++)
layerErr[l][j]=layer[l][j]*(1-layer[l][j])*(tar[j]-layer[l][j]);
while(l--0){
for(int j=0;jlayerErr[l].length;j++){
double z = 0.0;
for(int i=0;ilayerErr[l+1].length;i++){
z=z+l0?layerErr[l+1][i]*layer_weight[l][j][i]:0;
layer_weight_delta[l][j][i]= mobp*layer_weight_delta[l][j][i]+rate*layerErr[l+1][i]*layer[l][j];//隐含层动量调整
layer_weight[l][j][i]+=layer_weight_delta[l][j][i];//隐含层权重调整
if(j==layerErr[l].length-1){
layer_weight_delta[l][j+1][i]= mobp*layer_weight_delta[l][j+1][i]+rate*layerErr[l+1][i];//截距动量调整
layer_weight[l][j+1][i]+=layer_weight_delta[l][j+1][i];//截距权重调整
}
}
layerErr[l][j]=z*layer[l][j]*(1-layer[l][j]);//记录误差
}
}
}
public void train(double[] in, double[] tar){
double[] out = computeOut(in);
updateWeight(tar);
}
}
Q4: 使用java来实现在智能组卷中的遗传算法（急急急）
题目好像是让你做个增强版的List ，简单的都实现了 程序架子大概是这样，排序查找什么的百度搜下 算法很多，套着每样写个方法就行了，测试就在main‘方法里写
public class MyList {
private String[] arr;
private int count ;
public MyList (int count){
arr = new String[count];
this.count = count;
}
public MyList (int[] intArr){
arr = new String[intArr.length];
this.count = intArr.length;
for(int i=0;iintArr.length;i++){
arr[i] = intArr[i]+"";
}
}
public MyList (String[] stringArr){
arr = stringArr;
this.count = stringArr.length;
}
public int getLength(){
return count;
}
//清空容器内的数组。
public void clearAll(){
arr = new String[count];
}
//通过给定元素下标来删除某一元素
public void removeBySeqn(int seqn){
if(seqn = 0 seqncount){
arr[seqn] = null;
}
}
public static void main(String[] args){
MyList list = new MyList (40);
MyList list1 = new MyList ({3,2,125,56,123});
MyList list2 = new MyList ({"123",""ad});
list2.removeBySeqn(0);
list1.clearAll();
}
}
Q5: java中基数排序算法代码
/**
* 冒泡法排序br/
* li比较相邻的元素。如果第一个比第二个大，就交换他们两个。/li
* li对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。/li
* li针对所有的元素重复以上的步骤，除了最后一个。/li
* li持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。/li
*
* @param numbers
* 需要排序的整型数组
*/
public static void bubbleSort(int[] numbers) {
int temp; // 记录临时中间值
int size = numbers.length; // 数组大小
for (int i = 0; i size - 1; i++) {
for (int j = i + 1; j size; j++) {
if (numbers[i] numbers[j]) { // 交换两数的位置
temp = numbers[i];
numbers[i] = numbers[j];
numbers[j] = temp;
}
}
}
}
