java中的演算法

『壹』 java中實現計算加法的功能

你需要看一下swing事件的編寫，你需要調用文本框的getText方法得到裡面的數值，然後為「=」按鈕寫監聽事件，調用第三個文本框的setText方法顯示結果。我這里有個跟你界面相同的完善版，包括加減乘除運算的，我在代碼中用加粗著重突出了事件的那部分。import javax.swing.*;
import java.awt.*;
import java.awt.event.*;public class AA extends JFrame
{
protected JTextField tFirst,tSecond,tResult,tEqual;
private JComboBox cFu;
private JButton jOk;
private String sFuHao;
protected String sFirst;

float fFirst,fSecond,fResult;

private String cFuHao[] = {
"+","-","*","/"
};

public AA()
{
super( "Calculator" );

Container container = getContentPane();
container.setLayout( new FlowLayout() );
tFirst = new JTextField( 10 );
container.add( tFirst );
cFu = new JComboBox( cFuHao );
cFu.setMaximumRowCount( 3 );
container.add( cFu );
tSecond = new JTextField( 10 );
container.add( tSecond );

tEqual = new JTextField( "=", 1 );
tEqual.setEditable( false );
container.add( tEqual );

tResult = new JTextField( 10 );
tResult.setEditable( false );
container.add( tResult );

jOk = new JButton( "calculate" );
container.add( jOk );

ButtonHandler handler = new ButtonHandler();
jOk.addActionListener( handler );
setSize( 600,80 );
setVisible( true );

}

public static void main( String args[] )
{
AA application = new AA();
application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}

private class ButtonHandler implements ActionListener{

public void actionPerformed( ActionEvent event )
{
sFuHao=(String)cFu.getSelectedItem();
if((tFirst.getText()).equals("#")||(tSecond.getText()).equals("#"))
System.exit(0);

fFirst = Float.parseFloat(tFirst.getText());
fSecond = Float.parseFloat(tSecond.getText());

if(sFuHao.equals("+"))
fResult = fFirst + fSecond;
else if(sFuHao.equals("-"))
fResult = fFirst - fSecond;
else if(sFuHao.equals("*"))
fResult = fFirst * fSecond;
else
fResult = fFirst / fSecond;

tResult.setText( String.valueOf(fResult) );
}
}
}

『貳』 java中Math.random();演算法

把A，2，3，4，5，6，7，8，9，10，J,Q,K放進list！

這個還算小復雜！
要用hashmap放人和牌， Collections.shuffle(list)的一個方法洗牌！

用Math.random()這個就麻煩了，要寫個演算法，每次減一個元素！
如果是一副牌還好辦！2個數組分別存放花色和牌號，然後組合放進list里，洗牌，然後循環list。get((int)math.random());放進hashmap里！
然後list。remove（）！

『叄』 java編程裡面%如何計算

years%2 的結果只會有兩種 1 和 0 如果years是一個 」奇數「 那麼結果為0 如果」years」 是一個「偶數」那麼結果為1 奇數：不能被2整除的數 偶數：能被2整除的數

『肆』 java中遞歸演算法是什麼怎麼算的

一、遞歸演算法基本思路：

Java遞歸演算法是基於Java語言實現的遞歸演算法。遞歸演算法是一種直接或者間接調用自身函數或者方法的演算法。遞歸演算法實質是把問題分解成規模縮小的同類問題的子問題，然後遞歸調用方法表示問題的解。遞歸往往能給我們帶來非常簡潔非常直觀的代碼形式，從而使我們的編碼大大簡化，然而遞歸的思維確實跟我們的常規思維相逆的，通常都是從上而下的思維問題，而遞歸趨勢從下往上的進行思維。

二、遞歸演算法解決問題的特點：

【1】遞歸就是方法里調用自身。

【2】在使用遞歸策略時，必須有一個明確的遞歸結束條件，稱為遞歸出口。

【3】遞歸演算法代碼顯得很簡潔，但遞歸演算法解題的運行效率較低。所以不提倡用遞歸設計程序。

【4】在遞歸調用的過程中系統為每一層的返回點、局部量等開辟了棧來存儲。遞歸次數過多容易造成棧溢出等，所以一般不提倡用遞歸演算法設計程序。

【5】在做遞歸演算法的時候，一定把握出口，也就是做遞歸演算法必須要有一個明確的遞歸結束條件。這一點是非常重要的。其實這個出口就是一個條件，當滿足了這個條件的時候我們就不再遞歸了。

三、代碼示例：

publicclassFactorial{

//thisisarecursivefunction

intfact(intn){

if(n==1)return1;

returnfact(n-1)*n;

}}

publicclassTestFactorial{publicstaticvoidmain(String[]args){

//TODOAuto-generatedmethodstub

Factorialfactorial=newFactorial();

System.out.println("factorial(5)="+factorial.fact(5));

}
}

代碼執行流程圖如下：

此程序中n=5就是程序的出口。

『伍』 java中怎麼計算lgn！

math裡面有log 以e為底的函數 那你的lgN是以10為底，用個數學公式即可。lgN=loge N/ loge 10 就行了。謝謝採納

『陸』 java中&和&&是怎麼運算的

& 和 && 相同點：
都表示「與」操作。這里的「與」和數學中的「與或非」中的「與」意義相同，都遵循「一假必假」原則。即「與」符號兩邊的元素只要有一個為假，"與"操作執行後的結果就為假。

& 和 && 的區別：
1）& 表示「按位與"，這里的」位「是指二進制位（bit）。
例：十進制數字8 轉化為二進制是：1000 ；數字9 轉化為二進制是1001 。
則如有以下程序：
public class Test {
public static void main(String[] args) {
System.out.println(9 & 8);
}
}
輸出結果應該是：8
原因：1001 & 1000 = 1000 。 計算機中一般1表示真，0表示假。最左邊一位1&1=1，最右邊一位1&0 = 0.

2) && 表示邏輯」與「 ，即java中的boolean值才可以存在於&&符號的左右兩側。
true && false = false ，true && true = true ， 依舊是"一假必假"。
值的注意的是：&& 符號有所謂的「短路原則」，當 A && B 出現時，如果A經判斷是假，那麼B表達式將不會獲得執行或被判斷的機會。直接結果就為假。

註：關於十進制與二進制的轉換，簡單的說每四位可以遵循」8421「原則，1001即8+1=9，1011即8+2+1=11

『柒』 求一個java演算法

fd一個判斷，一個交換

package com.kangyong.demo11;

public class QuicksortExtra<T extends Comparable<T>> {
//快速排序
//直接拆成兩段，左邊排序，右邊排序然後組合。
//使整個集合有序
public static void sort(Comparable[] a){
int low = 0;
int high = a.length-1;
sort(a,low,high);
}
//是數組a中從low到high處有序
private static void sort(Comparable[] a, int low, int high) {
//出口當low>=high
if(low>=high)
{
return;
}
//使用partition方法排序
int partition = partition(a,low,high);
//讓左子組有序
sort(a,low,partition-1);
//讓右子組有序
sort(a,partition+1,high);
}
private static int partition(Comparable[] a, int low, int high) {
//確定分界值,分界值不是0是low
Comparable key = a[low];
//定義兩個指針，分別指向第一個位置，和最後一個位置+1
int left = low;
int right = high+1;
while (true){
//從右往左，移動right指針時
while (true){
right--;
//如果key分界值是奇數，（1.找到一個偶數停住，2.找到奇數並且&&比key小停住）
if((Integer)key%2==1){
if((Integer)a[right]%2==0)break;
if((Integer)a[right]%2==1&&less(a[right],key))break;
if(right==low)break;//走到頭跳出
}else {
//如果key分解值是偶數，（1.找到一個偶數並且&&比分解值大的停住，2.找到奇數不停）
if((Integer)a[right]%2==0&&!less(a[right],key))break;
if(right==low)break;
}
}
//然後在從左往右，移動left指針
while (true){
left++;
//如果key分解值是奇數，（1.找到一個奇數並且&& 比key大的停住，2.找到一個偶數停住並且）
if((Integer)key%2==1){
if(less(key,a[left])&&(Integer)a[left]%2==1)break;
if(left==high)break;
}else {//如果key分解值是偶數，（1.找到一個奇數停住，找到一個偶數並且&& 比key小的停住）
if((Integer)a[left]%2==1)break;
if((Integer)a[left]%2==0&&less(a[left],key))break;
if(left==high)break;//走到頭跳出。
}
}
//交換元素，出口是如果兩個指針相遇
if(left>=right){
break;
}else {
exchange(a,left,right);
}
}//while結束標記
//交換分解值,分界值所在的索引不是0，是low
exchange(a,low,right);
//返回人分界值索引
return right;
}
public static boolean less(Comparable a,Comparable b){
return a.compareTo(b)<0;
}
public static void exchange(Comparable[]a,int i,int j){
Comparable temp = a[i];
a[i]=a[j];
a[j]=temp;
}
}
//指針停住的條件：
//從右往左，移動right指針時
//如果key分界值是奇數，（1.找到一個偶數停住，2.找到奇數並且比key小停住）
//如果key分解值是偶數，（1.找到一個偶數並且比分解值小的停住，2.找到奇數不停）
//然後在從左往右，移動left指針
//如果key分解值是奇數，（1.找到一個奇數並且比key大的停住，2.找到一個偶數停住）
//如果key分解值是偶數，（1.找到一個奇數停住，找到一個偶數並且比key小的停住）

『捌』 java 演算法

//我自己寫的，核心演算法放在裡面，你在加一個主類調一下就行了
//兄弟，我親自測了，絕對可以
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;

//計算組合的演算法

public class CombinationClass {

public CombinationClass()
{

}
//對於任意n選m個元素，如果m==0,則此次排法結束，如果m不為0,那麼在n個元素中選擇m個元素就是要首先在n個元素中選出一個元素，然後
//在其他n-1個元素中選擇m-1個元素。因此，對於每一個n來講，它的任務就是，將當前傳入的集合中填充上自己的信息，然後比較是否有其他
//集合與自己所在集合相等如果這個集合長度為0,則重新建立一個集合，然後再把集合傳入到其他的數據中。

public ArrayList<HashSet> computeCombine(int cardinalNum, int ordinalNum,int[] numList, HashSet resultSet,ArrayList<HashSet> resultList)
{
//拷貝副本，而不能引用原來的HashSet
HashSet resultSetEnter = (HashSet)resultSet.clone();
//如果m==0則此次排法結束
if(ordinalNum == 0)
{ //完畢一種排法，把它添加到序列中
resultList.add(resultSetEnter);
return resultList;
}
if(numList.length != cardinalNum)
return null;
int newList[] = new int[numList.length - 1];
for(int i = 0; i < numList.length; i ++)
{
//每次隨便在cardinalNum中取出一個數，列印出來，然後在在其餘的cardinalNum-1個數中取ordinal-1次
//如果集合長度為0,則新建一個集合
HashSet resultSetCopy =(HashSet)resultSet.clone();
if(resultSetCopy.size() == 0)
resultSetCopy = new HashSet();

resultSetCopy.add(numList[i]);

//如果有其他集合與本集合相等，則返回
boolean result = false;
for(int k = 0; k < resultList.size(); k ++)
{
HashSet hashSet = resultList.get(k);
result = HashSetEqual(hashSet,resultSetCopy);
//如果有集合和該集合相等，則跳出循環
if(result == true)
break;
}
//如果有集合和該集合相等，則進行下一次循環
if(result == true)
continue;
//在該集合中添加入該元素

//刪掉numList[i]
for(int j = 0;j<i;j++)
{
newList[j] = numList[j];
}
for(int j = i + 1; j <= numList.length - 1; j ++)
{
newList[j - 1] = numList[j];
}

computeCombine(cardinalNum - 1,ordinalNum - 1, newList,resultSetCopy, resultList);
}

return null;
}

public static boolean HashSetEqual(HashSet hashSet, HashSet resultSetCopy)
{ int equal = 1;
Iterator it = hashSet.iterator();
if(resultSetCopy.size() == hashSet.size()){
while(it.hasNext())
{
if(equal == 0)
break;
if(equal == 1){
equal = 0;
int num = ((Integer)it.next()).intValue();
Iterator it2 = resultSetCopy.iterator();
while(it2.hasNext())
{
int num2 = ((Integer)it2.next()).intValue();
if(num == num2){
equal = 1;
break;
}
}
}
}
if(equal == 1)
return true;
else
return false;
}
return false;
}
}

『玖』 Java中要用那些演算法，演算法有什麼作用

常見演算法？
你指的是不是
數覺結構？
自己弄本有關的書看看吧。
java
和c/c++
一樣。只不過用不同的語言來實現相同的功能而已。