java写算法

B. 用Java写一个算法，把一串数字，所有可能的和按顺序排列，并计算每个和出现的次数

楼主你好

应你的要求 我只做了加一位的和加两位的
算法类代码如下:
public class CountSumClass {
private String number;
private String result = new String("");
public CountSumClass() {
number = new String();
}
public CountSumClass(String str) {
number = str;
}
public String getResult() {
return result;
}
public void addOne() {
int x,y;
for (int i = 0; i < number.length()-1; i++) {
x = (int)number.charAt(i) - 48;
for(int j = i+1; j<number.length(); j++) {
y = (int)number.charAt(j) - 48;
result += x+"+"+y+"="+(x+y)+"\n";
}
}
y=0;
for (int i = 0; i<number.length(); i++) {
x = (int)number.charAt(i) - 48;
y += x;
if(i == number.length()- 1) {
result += x+"="+y;
} else {
result += x+"+";
}
}
}
public void addTwo() {
int x,y,z;
result += "\n";
for (int i = 0; i<number.length()-1; i++) {
String substr = number.substring(i,i+2);
x = Integer.parseInt(substr);
z = (x%10) * 10 + (x/10);
for(int j=0; j<number.length(); j++) {
if(j!=i && j!=i+1) {
y = (int)number.charAt(j) - 48;
result += x+"+"+y+"="+(x+y)+"\n";
result += z+"+"+y+"="+(z+y)+"\n";
}
}
}
}
public String toString() {
return result;
}
}

希望能帮助你哈

C. 用java做算法好吗

java是建立在许多软件基础上的编程语言，对于算法程序的优化手段受到很大限制，这些都不利于做算法
可以考虑用c做算法，可以在兼顾可移植性的同时尽量优化，然后在java中调用。

D. java十大算法

算法一：快速排序算法
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。

算法步骤：

1 从数列中挑出一个元素，称为 "基准"（pivot），

2 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。

3 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

算法二：堆排序算法
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

堆排序的平均时间复杂度为Ο(nlogn) 。

算法步骤：

创建一个堆H[0..n-1]

把堆首（最大值）和堆尾互换

3. 把堆的尺寸缩小1，并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置

4. 重复步骤2，直到堆的尺寸为1

算法三：归并排序
归并排序（Merge sort，台湾译作：合并排序）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

算法步骤：

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列

2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置

3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

4. 重复步骤3直到某一指针达到序列尾

5. 将另一序列剩下的所有元素

E. java写算法，多个时间段，去掉重复之后的时间差（小时）

用文字表达一下算法思路吧
考虑到时间可能不是整点，让算法更兼容，这里统一将时间转换成基于00:00的精度到分的时间戳；
即07:00 = 7 * 60 = 420,10:00 = 10 * 60 = 600;

导入第一组工时数据
转换成时间戳，两个为一组
将连续的时间段存入数组
导入第N组工时数据并转换成时间戳
将第N组开工时间戳和收工时间戳和数组中的连续时间段进行比较
根据比较结果维护连续时间段的数组
根据数组计算出结果或者在循环处理数据时直接累加结果

F. 用java写算法

public class TextFilef{
public static String[] Analyze(String stringNumbers){

String numbers[]=new String[10];
int begin=0;
int end=0;
int count=0;
stringNumbers=stringNumbers.trim();
do{
end=stringNumbers.indexOf(' ');//第一个空格的位置
numbers[count++]=stringNumbers.substring(begin,end).trim();
//取得begin,end之间的子串

stringNumbers=stringNumbers.substring(end).trim();//去掉已经存到数组中的那些字符
}while(!stringNumbers.equals("")||stringNumbers.indexOf(' ')!=-1);//循环直到字符串中没有空格，或者字符串已经扫描完了,才会结束
return numbers;
}

}

楼主可以做一个测试程序册以下，我已经测试通过了。

G. 如何用JAVA写一个算法实现实际输入一个数N

import java.util.Scanner;

public class Test3 {

/**
* @param args
*/
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
System.out.println("请输入一个正整数n");
int num=in.nextInt();
int sum=1;
for(int i=1;i<=num;i++){
sum=sum*i;
}
System.out.println("sum="+sum);
}

}

H. 请用java设计一个算法

有一种非常简单的做法，直接利用现有的java API帮助你解决解决这个问题。
import java.util.Arrays;
import java.util.Comparator;
public class Test{
//newArray[] 为需要传入的数组对象
public static void reSortArray(String newArray[]){
String[] array = new String[]{"admin","viewer","operator","designer"}; //定义标准数组对象
final String str = Arrays.toString(array); //将标准数组对象中的数据转化为String
//使用Arrays类已实现好的数组排序方法，传入要排序的数组，以及比较器
Arrays.sort(newArray,new Comparator<String>(){
public int compare(String o1, String o2) {
return str.indexOf(o1)-str.indexOf(o2);
} } );
System.out.println(Arrays.toString(newArray)); //打印出排序后的数组内容
}
public static void main(String[] args) {
Test.reSortArray(new String[]{"operator","viewer","admin"} );//输出admin、viewer、operator
}
}

以上排序操作均由java api帮我们完成，性能方面比我们一个个比较要好的多。楼主如果对上述方法有啥不理解的地方，可以M我。

I. JAVA 实现算法

编码是不能用字符串的，大大大降低速度

public class Test{
static public int getIntegerComplement(int n){
return ~n&((1<<(32-Integer.numberOfLeadingZeros(n)))-1);
}
public static void main(String[] args){
int a[]={1,5,50,256,65536};
for(int i:a){
int r=getIntegerComplement(i);
System.out.println(i+" "+Integer.toBinaryString(i)+
" => "+r+" "+Integer.toBinaryString(r));
}
}
}
========
1 1 => 0 0
5 101 => 2 10
50 110010 => 13 1101
256 100000000 => 255 11111111
65536 10000000000000000 => 65535 1111111111111111