java算法

A. java算法

是JAVA里进制的问题，由于你在12的前面加了一个0，所以JVM会把它当做是一个八进制的数，八进制的012就是十进制里的10，所以没有错误！

B. Java算法

packagecom..;

importjava.math.BigDecimal;
importjava.util.ArrayList;
importjava.util.List;
importjava.util.Random;

publicclassNikeLoTest{
publicstaticvoidmain(String[]args){
//CreateRandomArrayforXandY
intsize=50;
double[]X=getRandomDoubles(0,0.4,size);
double[]Y=getRandomDoubles(0,9,size);
//pickupvalueinflectionpoint
List<Double>kList=newArrayList<>();
List<Double>jList=newArrayList<>();
for(inti=0;i<size-2;i++){//<-
if(isInflection(X,Y,i)){
kList.add(X[i]);
jList.add(Y[i]);
}
}
//K[i]J[i]
Double[]K=kList.toArray(newDouble[kList.size()]);
Double[]J=kList.toArray(newDouble[jList.size()]);
//Knew[]Jnew[]
Double[]Knew=roundAndRemoveDuplicateValue(K);
Double[]Jnew=roundAndRemoveDuplicateValue(J);
}

privatestaticDouble[]roundAndRemoveDuplicateValue(Double[]array){
List<Double>result=newArrayList<>();
for(Doubled:array){
BigDecimaltmp=newBigDecimal(d);
tmp=tmp.setScale(1,BigDecimal.ROUND_HALF_UP);
if(!result.contains(tmp.doubleValue())){
result.add(tmp.doubleValue());
}
}
returnresult.toArray(newDouble[result.size()]);
}

(double[]X,double[]Y,intn){
return(Y[n+1]-Y[n])*(Y[n+2]-Y[n+1])<0;
}

privatestaticdouble[]getRandomDoubles(doublerangeMin,doublerangeMax,
intsize){
double[]array=newdouble[size];
Randomr=newRandom();
for(inti=0;i<array.length;i++){
array[i]=rangeMin+(rangeMax-rangeMin)*r.nextDouble();
}
returnarray;
}
}

C. 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;
}
}

D. 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

E. Java算法是什么，为什么是精髓

怎么学习只是你达到目标的途径，只要自己学的好，学的精，达到一定高度的水平，精通解决问题的思路和方法。这与你自学和参见培训学习没啥大关系的，（唯一自学的话，太难了，而且可能学不全面，抓不到重点），只要达到用人单位的标准就OK了。java前景还是特好的！

F. java算法有什么用

你好，很高兴回答你的问题。
有一种说法是程序就是数据结构和算法的结合。
所以算法的作用我觉得是程序的基础吧。
如果有帮助到你，请点击采纳。

G. java中的算法，一共有多少种，哪几种，怎么分类。

就好比问，汉语中常用写作方法有多少种，怎么分类。

算法按用途分,体现设计目的、有什么特点
算法按实现方式分，有递归、迭代、平行、序列、过程、确定、不确定等等
算法按设计范型分，有分治、动态、贪心、线性、图论、简化等等

作为图灵完备的语言，理论上”Java语言“可以实现所有算法。
“Java的标准库'中用了一些常用数据结构和相关算法.

像apache common这样的java库中又提供了一些通用的算法

H. java算法有哪些分别

您好：

java中的算法，常见的有：递归、迭代、查找、排序（包含冒泡排序、选择排序、插入排序、快速排序四种） 等，算法有很多，一般数据结构中涉及到的都可以用java语言实现。

举几个例子：

1.递归的例子：

不一一举例，仅供参考！

I. Java中要用那些算法，算法有什么作用

常见算法？
你指的是不是
数觉结构？
自己弄本有关的书看看吧。
java
和c/c++
一样。只不过用不同的语言来实现相同的功能而已。

J. 求一个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小的停住）