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小的停住）