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++
一样。只不过用不同的语言来实现相同的功能而已。