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
2. 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;
}
}
3. java演算法有哪些分別
您好：
java中的演算法，常見的有：遞歸、迭代、查找、排序（包含冒泡排序、選擇排序、插入排序、快速排序四種） 等，演算法有很多，一般數據結構中涉及到的都可以用java語言實現。
舉幾個例子：
1.遞歸的例子：
不一一舉例，僅供參考！
4. JAVA演算法
是JAVA里進制的問題，由於你在12的前面加了一個0，所以JVM會把它當做是一個八進制的數，八進制的012就是十進制里的10，所以沒有錯誤！
5. Java 與 演算法+數據結構 （100分）
說數據結構沒用那是不可能的，但是要看你做什麼了。
比如說你要血java，如果你想搞網站方面的話就簡單了。
數據結構基本可以不用學，因為在web應用中，能用到的演算法的地方少之又少，幾乎就那麼幾個，想記不住都難。
但是如果你要往軟體方面和手軟方面發展的話就要學一部分了，但是這東西學是學不到的，能學到的只不過是思路，到時候自己發揮一下，想個演算法就行了，演算法這東西說難不難，難的東西有，但是沒有你能用到的。
像你這樣的情況我想說兩點：
首先，說你想從事演算法類的工作，那麼選擇什麼樣的語言都是一樣的，演算法肯定有，但是用到的都不多。剛進公司的時候一般是用不到演算法的，因為演算法都是別人想的，你也許有好的演算法，但是別人不一定採用，但是你的演算法基礎不要丟掉，因為等你當了項目經理後這個是必不可少的。
其次，你要知道，在學計算機的路上，很少有人能學什麼就做什麼，大家都在被社會潮流推動，想要不掉隊就只能隨波逐流。因為畢竟我們都不想一輩子寫代碼。大家都是拿這東西做個跳板。
學java的路很長，但是也很有趣，希望你能學好。我想以你的演算法基礎，以後想成為專業精英不是問題。加油吧。
6. java演算法編程
System.out.println("加油，你行的");7. 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;
}
}
8. java中的演算法，一共有多少種，哪幾種，怎麼分類。
就好比問，漢語中常用寫作方法有多少種，怎麼分類。
演算法按用途分,體現設計目的、有什麼特點
演算法按實現方式分，有遞歸、迭代、平行、序列、過程、確定、不確定等等
演算法按設計范型分，有分治、動態、貪心、線性、圖論、簡化等等
作為圖靈完備的語言，理論上」Java語言「可以實現所有演算法。
「Java的標准庫'中用了一些常用數據結構和相關演算法.
像apache common這樣的java庫中又提供了一些通用的演算法
9. 用java寫演算法
public class TextFilef{
public static String[] Analyze(String stringNumbers){
String numbers[]=new String[10];
int begin=0;
int end=0;
int count=0;
stringNumbers=stringNumbers.trim();
do{
end=stringNumbers.indexOf(' ');//第一個空格的位置
numbers[count++]=stringNumbers.substring(begin,end).trim();
//取得begin,end之間的子串
stringNumbers=stringNumbers.substring(end).trim();//去掉已經存到數組中的那些字元
}while(!stringNumbers.equals("")||stringNumbers.indexOf(' ')!=-1);//循環直到字元串中沒有空格，或者字元串已經掃描完了,才會結束
return numbers;
}
}
樓主可以做一個測試程序冊以下，我已經測試通過了。
10. 求一個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小的停住）