java復雜計算_java實現復雜計算器

A. java數據結構計算時間復雜度，一個小時在線等

你算最大值就可以了。前一半每個循環的最大index是n，所以是n*n*n。後一半的循環每個循環最大index是n*n，所以最後時間復雜度是(n*n)*(n*n)也就是n^4

B. 一個相當復雜的java編程題目！

package TestPackage;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Hashtable;
import java.util.Random;

/**
* @author songml
*
*/
public class ArrayTest {
/**
* @param args
*/
public static void main(String args[]) {

ArrayList arrayListTest = new ArrayList();
arrayListTest = initialize(10);
System.out.println("printArray:");
printArray(arrayListTest);
System.out.println("reverseArray:");
reverseArray(arrayListTest);
System.out.println("sumArray:");
sumArray(arrayListTest);
System.out.println("itilialize:");
arrayListTest = itilialize(50);
printArray(arrayListTest);
System.out.println("countArray:");
countArray(arrayListTest);
System.out.println("readArray:");
arrayListTest = readArray();
printOneInLine(arrayListTest);
}

private static void printOneInLine(ArrayList array) {
System.out.println("您輸入的字母是:"+array);

}

private static ArrayList readArray() {
InputStreamReader i = new InputStreamReader(System.in);
BufferedReader distream = new BufferedReader(i);
ArrayList arrayListTest = new ArrayList();
System.out.println("請輸入一行字母");
String s1 = "";
try {
s1 = distream.readLine();
} catch (IOException e) {
e.printStackTrace();
}

arrayListTest.add(s1);
return arrayListTest;
}

/**
* @param intparameters
* @return arrayList
*/
public static ArrayList initialize(int intparameters) {
ArrayList arrayList = new ArrayList();
Random rnd = new Random();
int x = 0;
for (int i=0; i < intparameters; i++) {
x = rnd.nextInt(intparameters);
arrayList.add(String.valueOf(x+1));
}
return arrayList;
}
/**
* @param intparameters
* @return ArrayList
*/
public static ArrayList itilialize(int intparameters) {
ArrayList arrayList = new ArrayList();
Random rnd = new Random();
int x = 0;
for (int i=0; i < intparameters; i++) {
x = rnd.nextInt(11);
arrayList.add(String.valueOf(10+x));
}
return arrayList;
}
/**
* @param array
*/
public static void countArray (ArrayList array) {
Hashtable hashTable = new Hashtable();
for (int i = 10;i <=20 ;i++ ) {
int count=0;
while (array.contains(String.valueOf(i))) {
array.remove(String.valueOf(i));
count ++;
}
hashTable.put(String.valueOf(i), String.valueOf(count));
}
for (int i = 10;i <=20 ;i++) {
System.out.print(i+"的個數："+hashTable.get(String.valueOf(i))+",");
}
System.out.println();
}
/**
* @param array
*/
public static void printArray(ArrayList array) {
System.out.println(array);
}
/**
* @param array
*/
public static void reverseArray(ArrayList array) {
Object temp ;
for(int i = 0 ;i < array.size()/2;i++) {
int intReverse = array.size()-1-i;
temp = array.get(i);
array.set(i, array.get(intReverse));
array.set(intReverse,temp);
}
System.out.println(array);

}

/**
* @param array
*/
public static void sumArray(ArrayList array) {
ArrayList arrayListTemp = new ArrayList();
arrayListTemp = array;
for(int i = 0 ;i < array.size();i++) {
if (i > 0) {
int tempSum = Integer.parseInt(arrayListTemp.get(i-1).toString())
+Integer.parseInt(array.get(i).toString());
arrayListTemp.set(i, String.valueOf(tempSum));
}
}
System.out.println(arrayListTemp);

}

}

寫了好久，，終於寫完了！！

C. java 計算時間復雜度

for(intp=0;p<n*n;p++)
for(intq=0;q<p;q++)
sum--;
下面我來簡單解釋一下為什麼是O（n^4）
p的所有取值，以及相對性的sum運算的次數如下
p的取值：01234...(n^2-1)
sum次數：00123...(n^2-2)
從上面的式子我們知道sum--執行的次數也就是sum次數的累加和：
0+0+1+2+3+...+(n^-2)=1+2+3+...+(n^2-2)這里我們可以用求和公式，但是需要搞定一個這里有多少項，很明顯(n^2-2)項，帶入求和公式如下
=(1+(n^2-2))*(n^2-2)/2=(n^2-1)(n^2-2)/2=(n^4-3*n^2+2)/2
所以答案是O(n^4)

D. 如何用java程序編寫復雜的計算公式程序

下面是代碼！
import java.util.Scanner;
class NumCount
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
System.out.println("請輸入你想累加的數的個數n:");
int sum=0;
int n;//n個數
n=in.nextInt();
for(int i=1;i<=n;i++){
sum+=i;
System.out.print(i!=n?i + "+":i);
}
System.out.println("="+sum);
}
}

E. java如何計算比較復雜的數學計算，比如有括弧同時有+-*/，順序不一定，就是一個運算公式

可以用編譯原理的思想來理解，主要用到數據結構裡面的棧和隊列。
利用棧的後進先出以及運算符號(+-*/(){} )優先順序，對運算符號進行匹配。
分兩個棧，一個是符號棧，一個是數字棧。
棧的每一次pop出一個字元，要進行校驗，如果匹配（符合運算規則）則計算，並保存結果到數據棧。

F. java的復雜運算符的次序

先求&&，再求|| ||從左到右依次執行 1 ((x>50)&&(y>60)) 2 ((x>50)&&(y<-60) 3 ((x>50)&&(y>60))||((x>50)&&(y<-60)) 4 ((x<-50)&&(y>60)) 5 ((x>50)&&(y>60))||((x>50)&&(y<-60))||((x<-50)&&(y>60)) 6 ((x<-50)&&(y<-60)) 7 ((x>50)&&(y>60))||((x>50)&&(y<-60))||((x<-50)&&(y>60))||((x<-50)&&(y<-60))

G. 數據結構裡面的時間復雜度怎麼計算Java版的！

很簡單啊...假設有N個數據（要求對其排序）。如果需要執行 N*N次才能處理完，我們就說該演算法的效率是o(n*n)。同理，如果需 n 次的話，就認為是 o(n)

H. java web如何實現復雜公式的計算問題

如果想純頁面端實現，使用JS計算。。。。。如果想JAVA，遞交給後台的servlet或JSP計算。

I. java實現復雜計算器

importjava.util.Scanner;

importjavax.script.ScriptEngine;
importjavax.script.ScriptEngineManager;
importjavax.script.ScriptException;

publicclassKyo
{
publicstaticvoidmain(String[]args)
{
ScriptEngineManagersem=newScriptEngineManager();
ScriptEnginese=sem.getEngineByName("js");
Scannerscan=newScanner(System.in);
while(true)
{
System.out.println("輸入一個式子：");
Stringjsonstr=scan.nextLine().trim();
try
{
doubled=Double.parseDouble(se.eval("("+jsonstr+")").toString());
System.out.printf("%s=%.1f%n",jsonstr,d);
}
catch(ScriptExceptione)
{
System.err.println("輸入的式子不合法，退出程序");
scan.close();
break;
}
}
}
}

J. JAVA中演算法的時間復雜程度是什麼

JAVA中演算法的時間復雜程度簡而言之就是運算時候的執行次數的統計
1.時間頻度
一個演算法執行所耗費的時間，從理論上是不能算出來的，必須上機運行測試才能知道。但我們不可能也沒有必要對每個演算法都上機測試，只需知道哪個演算法花費的時間多，哪個演算法花費的時間少就可以了。並且一個演算法花費的時間與演算法中語句的執行次數成正比例，哪個演算法中語句執行次數多，它花費時間就多。一個演算法中的語句執行次數稱為語句頻度或時間頻度。記為T(n)。
2.計算方法
1. 一般情況下，演算法的基本操作重復執行的次數是模塊n的某一個函數f（n），因此，演算法的時間復雜度記做：T（n）=O（f（n））分析：隨著模塊n的增大，演算法執行的時間的增長率和f（n）的增長率成正比，所以f（n）越小，演算法的時間復雜度越低，演算法的效率越高。 2. 在計算時間復雜度的時候，先找出演算法的基本操作，然後根據相應的各語句確定它的執行次數，再找出T（n）的同數量級（它的同數量級有以下：1，Log2n ，n ，nLog2n ，n的平方，n的三次方，2的n次方，n！），找出後，f（n）=該數量級，若T(n)/f(n)求極限可得到一常數c，則時間復雜度T（n）=O（f（n））
例：演算法：
for（i=1;i<=n;++i）
{
for(j=1;j<=n;++j)
{
c[ i ][ j ]=0; //該步驟屬於基本操作執行次數：n的平方次
for(k=1;k<=n;++k)
c[ i ][ j ]+=a[ i ][ k ]*b[ k ][ j ]; //該步驟屬於基本操作執行次數：n的三次方次
}
} 則有 T（n）= n的平方+n的三次方，根據上面括弧里的同數量級，我們可以確定 n的三次方為T（n）的同數量級
則有f（n）= n的三次方，然後根據T（n）/f（n）求極限可得到常數c
則該演算法的時間復雜度：T（n）=O（n的三次方）
3.分類
按數量級遞增排列，常見的時間復雜度有：常數階O(1),對數階O(log2n),線性階O(n), 線性對數階O(nlog2n),平方階O(n2)，立方階O(n3),...， k次方階O(nk), 指數階O(2n) 。隨著問題規模n的不斷增大，上述時間復雜度不斷增大，演算法的執行效率越低。

導航:首頁 > 編程語言 > java復雜計算

java復雜計算

與java復雜計算相關的資料