算法设计java
① java怎么用递归算法设计算法实现功能:求1+2!+3!+...+20!的和. 带下注释 才接触不太懂
import java.io.*;
public class Sum {
public static int sum(int n) {
if (n < 1)
return 0;
else
return sum(n - 1) + n;
}
public static void main(String args[]) {
int result = 0;
String str;
int num = 0;
System.out.println("Please input the number:"兆铅高);
try {
DataInputStream in = new DataInputStream(System.in);
str = in.readLine(); // 输入的数字字符串
num = Integer.parseInt(str); // 字激野符串转换成整数值
} catch (Exception e) {
}
result = sum(num);// 调用sum（），求1+2+3+····+num，这个result好像要小写
System.out.println(result); // 按行输出结果
}
}
调整过了，结果是对族尺的，程序也可以运行了
你这个题中好多错误啊，大小写、中文的，运行起来还得改，从哪里复制的啊！
② Java算法设计 请问这个乘法表的算法设计怎么画
算法设计怎么画？？什么意思？？乘法表嘛
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
...
1*9=9 2*9=18 3*9=27 ...
m(i+1)递归自己调用自己嘛
if(){
因为闭销姿这里没有递归所以当i==9时候进入
打印就轿绝结束了
}else{
否则一直自己调用自己
递归
｝
递归少用点，一般递归可以的循环都能解决比递归好也好理解！！
递归斗岁还容易照成栈溢出。
③ Java算法设计：迭代器实现排序（求各位大佬各抒己见）
public static void bubbleSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
for (int e = arr.length - 1; e > 0; e--) {
for (int i = 0; i < e; i++) {
if (arr[i] > arr[i + 1]) {
swap(arr, i, i + 1);
}
}
}
}
④ 用JAVA设计一个简单的加密、解密算法，用该算法来实现对数据的加密、解密
简单的?
用异或就可以了..!
importjava.util.Scanner;
publicclass加密
{
privatestaticScannersc=newScanner(System.in);
publicstaticvoidmain(String[]Args)
{
System.out.println(" ================字符串加密演示===================== ");
init();
}
//初始化!
privatestaticvoidinit()
{
for(;;)
{
char[]arr=input();
jiaMi(arr,20140908);
jiaMi(20140908,arr);
}
}
//键盘录取!
privatestaticchar[]input()
{
Strings=sc.nextLine();
inta=s.length();
char[]arr=newchar[a];
//char[]arr=s.toCharArray();
for(inti=0;i<s.length();i++)
{
arr[i]=s.charAt(i);
}
returnarr;
}
//加密!!
privatestaticvoidjiaMi(char[]arr,inta)
{
for(inti=0;i<arr.length;i++)
{
arr[i]=((char)(arr[i]^a));
}
System.out.println("加密完成!");
print(arr);
}
//解密!!
privatestaticvoidjiaMi(inta,char[]arr)
{
for(inti=0;i<arr.length;i++)
{
arr[i]=((char)(arr[i]^a));
}
System.out.println("解密完成");
print(arr);
}
//打印!!
privatestaticvoidprint(char[]arr)
{
for(inti=0;i<arr.length;i++)
{
System.out.print(arr[i]);
}
System.out.println(" ========================= ");
}
}
⑤ java 算法设计 多数组递归操作
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ArrayAssemble {
@SuppressWarnings("unchecked")
public static void main(String[] args) {
Integer[] arrOfInt = { 1, 2, 3 };
@SuppressWarnings("unused")
Character[] arrOfChar1 = { 'a', 'b', 'c' };
@SuppressWarnings("unused")
Character[] arrOfChar2 = { '!', '@', '#' };
String[] arrOfStr = { "lmy", "lyb", "mz", "yx" };
System.out.println("以下是组合后的数组盯猛");
// List arrayList = assembleArraysToList(arrOfInt);
// for (int n = 0; n < arrayList.size(); n++) {
// Object obj = arrayList.get(n);
// if (obj instanceof Object[]) {
// Object[] objArr = (Object[]) obj;
// System.out.println(Arrays.toString(objArr));
// } else {
// System.out.println(obj);
// }
//
// }
Object[][] objectsArrays = assembleArraysToPlanerArray(new Object[][] {
arrOfInt, arrOfChar1, arrOfChar2, arrOfStr });
for (Object[] objArrays : objectsArrays) {
System.out.println(Arrays.toString(objArrays));
}
}
// 方法一：使用可变参数方法返回数组类型的List
@SuppressWarnings("unchecked")
public static List assembleArraysToList(Object[]... objects) {
List arrayList = new ArrayList();
// 遍历方法的凯厅桥参数
for (int i = 0; i < objects.length; i++) {
if (i == 0) {
// 对于第一个数组参数,先将其转变成List类型,以便能使用辅助方法进行处理
arrayList = Arrays.asList(objects[i]);
} else {
// 对从第二个参数开始的数组与前面组合过的列表进行组合
arrayList = assembleArrayToList(arrayList, objects[i]);
}
}
return arrayList;
}
// 方法一的辅伏册助方法：将一个数组类型或对象类型的List与数组组合，并返回List
@SuppressWarnings("unchecked")
public static List assembleArrayToList(List aList, Object[] array) {
List arrList = new ArrayList();
// 遍历aList,将array与aList进行组合
for (int i = 0; i < aList.size(); i++) {
Object obj = aList.get(i);
// 检查aList的元素是否是数组类型的，如果不是，则直接产生组合列表
if (obj instanceof Object[]) {
Object[] listArr = (Object[]) obj;
// 对数组类型的aList元素与array进行组合
for (int k = 0; k < array.length; k++) {
Object[] newListArr = new Object[listArr.length + 1];
for (int j = 0; j < listArr.length; j++) {
newListArr[j] = listArr[j];
}
newListArr[listArr.length] = array[k];
arrList.add(newListArr);
}
} else {
// 对非数组类型的aList元素与array进行组合
for (int j = 0; j < array.length; j++) {
Object[] arrObj = { aList.get(i), array[j] };
arrList.add(arrObj);
}
}
}
return arrList;
}
// 方法二：使用二维数组参数方法返回组合的二维数组类型，并使用了递归
@SuppressWarnings("unchecked")
public static Object[][] assembleArraysToPlanerArray(Object[][] objectArrays) {
if (objectArrays.length == 2) {
Object[] assembledArray = objectArrays[0];
Object[] array = objectArrays[1];
return assembleArrayToArray(assembledArray, array);
} else if (objectArrays.length <= 1) {
return objectArrays;
} else {
Object[] objArray = objectArrays[objectArrays.length - 1];
objectArrays = Arrays.Of(objectArrays, objectArrays.length - 1);
return assembleArrayToArray(
assembleArraysToPlanerArray(objectArrays), objArray);
}
}
// 方法二的辅助方法：将一个数组类型或二维数组类型与数组组合，并返回二维数组
public static Object[][] assembleArrayToArray(Object[] assembledArray,
Object[] array) {
int lenAssArray = assembledArray.length;
int lenArray = array.length;
Object[][] objArrays = new Object[lenAssArray * lenArray][];
for (int i = 0; i < lenAssArray; i++) {
Object obj = assembledArray[i];
if (obj instanceof Object[]) {
Object[] objArr = (Object[]) obj;
int lenObjArr = objArr.length;
for (int k = 0; k < lenArray; k++) {
// 复制objArr数组到newListArr数组，并将其长度加一
Object[] newListArr = Arrays.Of(objArr, lenObjArr + 1);
//将array数组的第k+1元素赋值给newListArr数组最后的元素,并将newListArr赋值给objArrays数组的第k+1个元素
newListArr[lenObjArr] = array[k];
objArrays[lenArray * i + k] = newListArr;
}
} else {
for (int j = 0; j < lenArray; j++) {
Object[] newObjArray = { obj, array[j] };
objArrays[lenArray * i + j] = newObjArray;
}
}
}
return objArrays;
}
}
//我自己写的方法，用了一天的时间，希望能够采纳,对了，运行环境是JDK1.6
⑥ 什么是算法与程序设计 java
算法就是吧一个实际问题抽象成数学模型，就是解决一个问题的所有步槐扒晌骤（计算机解决问题的方法和人不一样，所以人要设计能用计算机的方式解决问题的方法）铅锋。而往此态往精妙的算法需要用到数据结构，所以算法和数据结构密不可分。
⑦ java 设计算法，计算用后缀表示法表示的算术表达式的值。
你好！
后缀表达式也称逆波兰表达式，其优点就在于可以方便的用栈实现表达式的值的计算。和你说一下思路吧：
·从头读入表达式
·如果遇到数则将其压入栈
·如果遇到运算符，从栈中弹出栈顶连个数，实行相应运算，将结果压入栈中
·直到表达式尾，此时栈中应该只有一个元素，即运算结果
·Over
如果对你有帮助，望采纳。
⑧ 算法设计与程序实现:java,100元的具体划分方案,可选面值有1元,10元,20元,50元,100元.
for( int a=0,loopCountA=100/100; a<=loopCountA; a++ )
for( int b=0,loopCountB=(100-a*100)/50; b<=loopCountB; b++ )
for( int c=0,loopCountC=(100-a*100-b*50)/20; c<=loopCountC; c++ )
for( int d=0,loopCountD=(100-a*100-b*50-c*20)/10; d<=loopCountD; d++ )
for( int e=0,loopCountE=(100-a*100-b*50-c*20-d*10)/1; e<=loopCountE; e+=10 )
if( (a*100+b*50+c*20+d*10+e)==100 )
System.out.println("1元："+e+"张；10元："+d+"张；20元："+c+"张；50元："+b+"张；100元："+a+"张。");
改进了下，速度快了一些。
⑨ 有没有专用于JAVA的算法设计与分析书籍
一、入门
《Java 2从入门到精通》－ 推荐
《Thinking in Java》－ 强烈推荐*
O’reilly的Java编程基础系列 － 参考*
二、进阶
《Java Cook Book》－ 非常推荐* （包含了Java编程的Tips，适合当做手册来查阅）
《O’reilly-Java IO》－ 推荐* （包含Java IO编程的各个方面）
《O’reilly-Database Programming with JDBC》－ 推荐* （JDBC编程）
《O’reilly-Java Programming with Oracle JDBC》－ 参考*
三、Java Web编程
《O’reilly-Java Server Pages》－ 强烈推荐*
《O’reilly-Java Servlet Programming》－ 非常推荐*
《O’唯袜reilly-Jakarta Struts》－ 推荐* （Java Web编程的一个MVC实现框架Struts的书）
四、EJB编程
《J2EE应用与BEA Weblogic Server》－ 强烈推荐
《Mastering EJB 2.0》－ 非常推荐*
《Enterprise Java Bean》－ 推荐*
五、Java XML编程
《O’reilly-Java and XML》－ 推荐*
《O’reilly-Java and SOAP》－ 参考* （Java的SOAP编程）
六、设计模式
《Core J2EE Patterns》－ 强指颂激烈推荐* （J2EE设计模式，设计企业应用软件必备参考书）
《EJB Design Patterns》－ 推荐*
七、其它
《O’reilly Ant - The Definitive Guide》－ 推荐* （Ant是一种功能非常强大的Java工具）
Note:
强烈推荐书籍：建议樱漏购买，重点学习
非常推荐书籍：建议花时间学习
推荐书籍：在学有余力的情况下，建议学习
参考书籍：有兴趣的情况下学习
标明*号的书籍有电子版本
⑩ java算法设计问题（贪心算法）
第一、你说的那个东西不叫框架
第二、你用的算法不是多稿游芹路合并
第三、题目不是让你合并、是让你找出最优解
解答，我晕这题目有啥解答的啊，你不是自己编的吧，假如合并两个有序序列只要m+n-1次比较，那么不单单这两个序列各自有序，同时其中一个序列任意元素大于另外一个序列所有元素
那么答案就是按照k的序号从前想磨伏后依次合并键毕啊