java算法大全（java中的算法，一共有多少种，哪几种，怎么分类）

本文目录

• java中的算法，一共有多少种，哪几种，怎么分类
• java中常用的算法，有哪些告诉我名字就可以了越多越好
• java面试有哪些算法
• Java算法
• java 算法

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

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

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

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

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

java中常用的算法，有哪些告诉我名字就可以了越多越好

插入排序
选择排序
冒泡排序
快速排序
归并排序
希尔排序
堆排序
桶式排序
基数排序
前面几个常用点吧
不过我这种低级程序员
都用的不多
哎

java面试有哪些算法

面试-java算法题：
1.编写一个程序，输入n,求n！（用递归的方式实现）。
public static long fac(int n){ if(n《=0) return 0; else if(n==1) return 1; else return n*fac(n-1);
} public static void main(String args) {
System.out.println(fac(6));
}
2.编写一个程序，有1，2,3,4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？
public static void main(String args) { int i, j, k; int m=0; for(i=1;i《=4;i++) for(j=1;j《=4;j++) for(k=1;k《=4;k++){ if(i!=j&&k!=j&&i!=k){
System.out.println(““+i+j+k);
m++;
}
}
System.out.println(“能组成：“+m+“个“);
}
3.编写一个程序，将text1.txt文件中的单词与text2.txt文件中的单词交替合并到text3.txt文件中。text1.txt文件中的单词用回车符分隔，text2.txt文件中用回车或空格进行分隔。
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;

public class text{
public static void main(String args) throws Exception{
String a = getArrayByFile(“text1.txt“,new char{’\n’});
String b = getArrayByFile(“text2.txt“,new char{’\n’,’ ’});
FileWriter c = new FileWriter(“text3.txt“);
int aIndex=0; int bIndex=0;

while(aIndex《a.length){
c.write(a[aIndex++] + “\n“);
if(bIndex《b.length)
c.write(b[bIndex++] + “\n“);
}

while(bIndex《b.length){
c.write(b[bIndex++] + “\n“);
}
c.close();
}

public static String getArrayByFile(String filename,char seperators) throws Exception{
File f = new File(filename);
FileReader reader = new FileReader(f);
char buf = new char[(int)f.length()];
int len = reader.read(buf);
String results = new String(buf,0,len);
String regex = null;
if(seperators.length 》1 ){
regex = ““ + seperators + “|“ + seperators;
}else{
regex = ““ + seperators;
}
return results.split(regex);
}

}
4.639172每个位数上的数字都是不同的，且平方后所得数字的所有位数都不会出现组成它自身的数字。（639172*639172=408540845584），类似于639172这样的6位数还有几个？分别是什么？
这题采用的HashMap结构判断有无重复，也可以采用下题的数组判断。
public void selectNum(){
for(long n = 100000; n 《= 999999;n++){
if(isSelfRepeat(n)) //有相同的数字，则跳过
continue;
else if(isPingFangRepeat(n*n,n)){ //该数的平方中是否有与该数相同的数字
continue;
} else{ //符合条件，则打印 System.out.println(n);
}
}
} public boolean isSelfRepeat(long n){
HashMap《Long,String》 m=new HashMap《Long,String》(); //存储的时候判断有无重复值
while(n!=0){ if(m.containsKey(n%10)){ return true;
} else{
m.put(n%10,“1“);
}
n=n/10;
} return false;
} public boolean isPingFangRepeat(long pingfang,long n){
HashMap《Long,String》 m=new HashMap《Long,String》(); while(n!=0){
m.put(n%10,“1“);
n=n/10;
} while(pingfang!=0){ if(m.containsKey(pingfang%10)){ return true;
}
pingfang=pingfang/10;
} return false;
} public static void main(String args){ new test().selectNum();
}
5.比如，968548+968545=321732732它的答案里没有前面两个数里的数字，有多少这样的6位数。
public void selectNum(){
for(int n = 10; n 《= 99;n++){
for(int m = 10; m 《= 99;m++){ if(isRepeat(n,m)){ continue;
} else{
System.out.println(“组合是“+n+“,“+m);
}
}
}
} public boolean isRepeat(int n,int m){ int a={0,0,0,0,0,0,0,0,0,0}; int s=n+m; while(n!=0){
a[n%10]=1;
n=n/10;
} while(m!=0){
a[m%10]=1;
m=m/10;
} while(s!=0){ if(a[s%10]==1){ return true;
}
s=s/10;
} return false;
} public static void main(String args){ new test().selectNum();
}
6.给定String,求此字符串的单词数量。字符串不包括标点，大写字母。例如 String str=“hello world hello hi“;单词数量为3，分别是：hello world hi。
public static void main(String args) { int count = 0;
String str=“hello world hello hi“;
String newStr=““;
HashMap《String,String》 m=new HashMap《String,String》();
String a=str.split(“ “); for (int i=0;i《a.length;i++){ if(!m.containsKey(a[i])){
m.put(a[i],“1“);
count++;
newStr=newStr+“ “+a[i];
}
}
System.out.println(“这段短文单词的个数是：“+count+“,“+newStr);
}
7.写出程序运行结果。
public class Test1 { private static void test(intarr) { for (int i = 0; i 《 arr.length; i++) { try { if (arr[i] % 2 == 0) { throw new NullPointerException();
} else {
System.out.print(i);
}
} catch (Exception e) {
System.out.print(“a “);
} finally {
System.out.print(“b “);
}
}
}
public static void main(Stringargs) { try {
test(new int {0, 1, 2, 3, 4, 5});
} catch (Exception e) {
System.out.print(“c “);
}
}

}
运行结果：a b 1b a b 3b a b 5b
public class Test1 { private static void test(intarr) { for (int i = 0; i 《 arr.length; i++) { try { if (arr[i] % 2 == 0) { throw new NullPointerException();
} else {
System.out.print(i);
}
}
finally {
System.out.print(“b “);
}
}
}
public static void main(Stringargs) { try {
test(new int {0, 1, 2, 3, 4, 5});
} catch (Exception e) {
System.out.print(“c “);
}
}

}
运行结果：b c
8.单词数
统计一篇文章里不同单词的总数。
Input
有多组数据，每组一行，每组就是一篇小文章。每篇小文章都是由小写字母和空格组成，没有标点符号，遇到#时表示输入结束。
Output
每组值输出一个整数，其单独成行，该整数代表一篇文章里不同单词的总数。
Sample Input
you are my friend
#
Sample Output
4
public static void main(String args) {
List《Integer》 countList=new ArrayList《Integer》(); int count;
HashMap《String,String》 m;
String str; //读取键盘输入的一行（以回车换行为结束输入） String a;

Scanner in=new Scanner(System.in);
while( !(str=in.nextLine()).equals(“#“) ){
a=str.split(“ “);
m=new HashMap《String,String》();
count = 0; for (int i=0;i《a.length;i++){ if(!m.containsKey(a[i]) && (!a[i].equals(““))){
m.put(a[i],“1“);
count++;
}
}
countList.add(count);
}s for(int c:countList)
System.out.println(c);
}

Java算法

package com.baidu.zhidao;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class NikeLoTest {
    public static void main(String args) {
        // Create Random Array for X and Y
        int size = 50;
        double X = getRandomDoubles(0, 0.4, size);
        double Y = getRandomDoubles(0, 9, size);
        // pick up value inflection point
        List《Double》 kList = new ArrayList《》();
        List《Double》 jList = new ArrayList《》();
        for (int i = 0; i 《 size - 2; i++) { // 《- avoid ArrayIndexOutOfBoundsException
            if (isInflection(X, Y, i)) {
                kList.add(X[i]);
                jList.add(Y[i]);
            }
        }
        // K[i] J[i]
        Double K = kList.toArray(new Double[kList.size()]);
        Double J = kList.toArray(new Double[jList.size()]);
        // Knew Jnew
        Double Knew = roundAndRemoveDuplicateValue(K);
        Double Jnew = roundAndRemoveDuplicateValue(J);
    }

    private static Double roundAndRemoveDuplicateValue(Double array) {
        List《Double》 result = new ArrayList《》();
        for (Double d : array) {
            BigDecimal tmp = new BigDecimal(d);
            tmp = tmp.setScale(1, BigDecimal.ROUND_HALF_UP);
            if (!result.contains(tmp.doubleValue())) {
                result.add(tmp.doubleValue());
            }
        }
        return result.toArray(new Double[result.size()]);
    }

    private static boolean isInflection(double X, double Y, int n) {
        return (Y[n + 1] - Y[n]) * (Y[n + 2] - Y[n + 1]) 《 0;
    }

    private static double getRandomDoubles(double rangeMin, double rangeMax,
            int size) {
        double array = new double[size];
        Random r = new Random();
        for (int i = 0; i 《 array.length; i++) {
            array[i] = rangeMin + (rangeMax - rangeMin) * r.nextDouble();
        }
        return array;
    }
}

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