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