算法题java
public class Monkey
{
public static void main(String[] args)
{
int sum=0,remain=1;
//每天吃剩的桃子加一个正好是前一天桃子的一半，每天桃子的总数就是前一天剩下桃子的数量
for(int day=9;day>=1;day--)
{
sum=(remain+1)*2;
remain=sum;
System.out.println("第"+day+"天还剩"+remain+"个桃子");
}
System.out.println(sum);
}
}
❷ java算法面试题：排序都有哪几种方法
一、冒泡排序
[java] view plain
package sort.bubble;
import java.util.Random;
/**
* 依次比较相邻的两个数，将小数放在前面，大数放在后面
* 冒泡排序，具有稳定性
* 时间复杂度为O（n^2）
* 不及堆排序，快速排序O（nlogn，底数为2）
* @author liangge
*
*/
public class Main {
public static void main(String[] args) {
Random ran = new Random();
int[] sort = new int[10];
for(int i = 0 ; i < 10 ; i++){
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的数组为");
for(int i : sort){
System.out.print(i+" ");
}
buddleSort(sort);
System.out.println();
System.out.print("排序后的数组为");
for(int i : sort){
System.out.print(i+" ");
}
}
/**
* 冒泡排序
* @param sort
*/
private static void buddleSort(int[] sort){
for(int i=1;i<sort.length;i++){
for(int j=0;j<sort.length-i;j++){
if(sort[j]>sort[j+1]){
int temp = sort[j+1];
sort[j+1] = sort[j];
sort[j] = temp;
}
}
}
}
}
二、选择排序
[java] view plain
package sort.select;
import java.util.Random;
/**
* 选择排序
* 每一趟从待排序的数据元素中选出最小（或最大）的一个元素，
* 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
* 选择排序是不稳定的排序方法。
* @author liangge
*
*/
public class Main {
public static void main(String[] args) {
Random ran = new Random();
int[] sort = new int[10];
for (int i = 0; i < 10; i++) {
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的数组为");
for (int i : sort) {
System.out.print(i + " ");
}
selectSort(sort);
System.out.println();
System.out.print("排序后的数组为");
for (int i : sort) {
System.out.print(i + " ");
}
}
/**
* 选择排序
* @param sort
*/
private static void selectSort(int[] sort){
for(int i =0;i<sort.length-1;i++){
for(int j = i+1;j<sort.length;j++){
if(sort[j]<sort[i]){
int temp = sort[j];
sort[j] = sort[i];
sort[i] = temp;
}
}
}
}
}
三、快速排序
[java] view plain
package sort.quick;
/**
* 快速排序 通过一趟排序将要排序的数据分割成独立的两部分， 其中一部分的所有数据都比另外一部分的所有数据都要小，
* 然后再按此方法对这两部分数据分别进行快速排序， 整个排序过程可以递归进行，以此达到整个数据变成有序序列。
* @author liangge
*
*/
public class Main {
public static void main(String[] args) {
int[] sort = { 54, 31, 89, 33, 66, 12, 68, 20 };
System.out.print("排序前的数组为：");
for (int data : sort) {
System.out.print(data + " ");
}
System.out.println();
quickSort(sort, 0, sort.length - 1);
System.out.print("排序后的数组为：");
for (int data : sort) {
System.out.print(data + " ");
}
}
/**
* 快速排序
* @param sort 要排序的数组
* @param start 排序的开始座标
* @param end 排序的结束座标
*/
public static void quickSort(int[] sort, int start, int end) {
// 设置关键数据key为要排序数组的第一个元素，
// 即第一趟排序后，key右边的数全部比key大，key左边的数全部比key小
int key = sort[start];
// 设置数组左边的索引，往右移动判断比key大的数
int i = start;
// 设置数组右边的索引，往左移动判断比key小的数
int j = end;
// 如果左边索引比右边索引小，则还有数据没有排序
while (i < j) {
while (sort[j] > key && j > start) {
j--;
}
while (sort[i] < key && i < end) {
i++;
}
if (i < j) {
int temp = sort[i];
sort[i] = sort[j];
sort[j] = temp;
}
}
// 如果左边索引比右边索引要大，说明第一次排序完成，将sort[j]与key对换，
// 即保持了key左边的数比key小，key右边的数比key大
if (i > j) {
int temp = sort[j];
sort[j] = sort[start];
sort[start] = temp;
}
//递归调用
if (j > start && j < end) {
quickSort(sort, start, j - 1);
quickSort(sort, j + 1, end);
}
}
}
[java] view plain
/**
* 快速排序
*
* @param a
* @param low
* @param high
* voidTest
*/
public static void kuaisuSort(int[] a, int low, int high)
{
if (low >= high)
{
return;
}
if ((high - low) == 1)
{
if (a[low] > a[high])
{
swap(a, low, high);
return;
}
}
int key = a[low];
int left = low + 1;
int right = high;
while (left < right)
{
while (left < right && left <= high)// 左边向右
{
if (a[left] >= key)
{
break;
}
left++;
}
while (right >= left && right > low)
{
if (a[right] <= key)
{
break;
}
right--;
}
if (left < right)
{
swap(a, left, right);
}
}
swap(a, low, right);
kuaisuSort(a, low, right);
kuaisuSort(a, right + 1, high);
}
四、插入排序
[java] view plain
package sort.insert;
/**
* 直接插入排序
* 将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据
* 算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。
*/
import java.util.Random;
public class DirectMain {
public static void main(String[] args) {
Random ran = new Random();
int[] sort = new int[10];
for (int i = 0; i < 10; i++) {
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的数组为");
for (int i : sort) {
System.out.print(i + " ");
}
directInsertSort(sort);
System.out.println();
System.out.print("排序后的数组为");
for (int i : sort) {
System.out.print(i + " ");
}
}
/**
* 直接插入排序
*
* @param sort
*/
private static void directInsertSort(int[] sort) {
for (int i = 1; i < sort.length; i++) {
int index = i - 1;
int temp = sort[i];
while (index >= 0 && sort[index] > temp) {
sort[index + 1] = sort[index];
index--;
}
sort[index + 1] = temp;
}
}
}
顺便添加一份，差不多的
[java] view plain
public static void charuSort(int[] a)
{
int len = a.length;
for (int i = 1; i < len; i++)
{
int j;
int temp = a[i];
for (j = i; j > 0; j--)//遍历i之前的数字
{
//如果之前的数字大于后面的数字，则把大的值赋到后面
if (a[j - 1] > temp)
{
a[j] = a[j - 1];
} else
{
break;
}
}
a[j] = temp;
}
}
把上面整合起来的一份写法：
[java] view plain
/**
* 插入排序:
*
*/
public class InsertSort {
public void sort(int[] data) {
for (int i = 1; i < data.length; i++) {
for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {
swap(data, j, j - 1);
}
}
}
private void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
}
五、顺便贴个二分搜索法
[java] view plain
package search.binary;
public class Main {
public static void main(String[] args) {
int[] sort = {1,2,3,4,5,6,7,8,9,10};
int mask = binarySearch(sort,6);
System.out.println(mask);
}
/**
* 二分搜索法，返回座标，不存在返回-1
* @param sort
* @return
*/
private static int binarySearch(int[] sort,int data){
if(data<sort[0] || data>sort[sort.length-1]){
return -1;
}
int begin = 0;
int end = sort.length;
int mid = (begin+end)/2;
while(begin <= end){
mid = (begin+end)/2;
if(data > sort[mid]){
begin = mid + 1;
}else if(data < sort[mid]){
end = mid - 1;
}else{
return mid;
}
}
return -1;
}
}
❸ java算法题
快速排序一般来说 比较适用于数据量大的情况
public class QuickSoft {
private void swap(int a[],int i,int j)
{
int tmp=a[i];
a[i]=a[j];
a[j]=tmp;
}
private int partition(int a[],int p,int r)
{
int point = a[r];
//将小于等于point的元素移到左边区域
//将大于point的元素移到右边区域
int index=p;
for (int i = index; i < r; ++ i) {
if (a[i]-point <= 0) {
swap(a, index++, i);
}
}
swap(a,index,r);
return index;
}
public void qsort(int a[],int p,int r)
{
if(p< r)
{
//确定拆分点，并对数组元素进行移动
//这是快速排序算法的关键步骤
int q=partition(a,p,r);
//对左半段排序
qsort(a,p,q-1);
//对右半段排序
qsort(a,q+1,r);
}
}
public static void main(String[] args) {
//声明一个类
QuickSoft ms=new QuickSoft();
int len=10;
int a[]=new int[len];
//初始化a数组
System.out.println("原始数组如下：");
for(int i=0;i< a.length;i++)
{
//产生a.length个随机数
a[i] = (int)(Math.random()*100000);
System.out.println(a[i]);
}
System.out.println("---------------------");
System.out.println("第一次分组后");
ms.partition(a,0,len-1);
for(int i=0;i< a.length;i++)
{
System.out.println(a[i]);
}
System.out.println("---------------------");
//快速排序
ms.qsort(a, 0, len-1);
System.out.println("排序后的数组如下：");
for(int i=0;i< a.length;i++)
{
System.out.println(a[i]);
}
}
}
❹ java算法题——龟兔赛跑
packagep1;
importjava.util.Scanner;
/**
*龟兔赛跑
*
*@authoryugi
*/
publicclassTortoiseHare
{
publicstaticfinalStringT="T";
publicstaticfinalStringR="R";
publicstaticfinalStringD="D";
privatestaticvoidrace(intv1,intv2,intt,ints,intl,
intstart1,intstart2,ints1,ints2,inttime,
booleanrest)
{
if(
v1<0||v2<0||t<0||s<0||l<0
||v1>100||v2>100||t>300||s>10||l>10000
||l%v1!=0||l%v2!=0
)
{
try
{
thrownewException("参数输入不合标准!");
}
catch(Exceptione)
{}
}
else
{
//兔子或乌龟已经到达终点
if(s1>=l||s2>=l)
{
if(s1>s2)
{
System.out.println(R);
System.out.println(time+start1);
}
elseif(s1<s2)
{
System.out.println(T);
System.out.println(start2);
}
else
{
System.out.println(D);
System.out.println(start2);
}
return;
}
//兔子开始休息
if(!rest&&s1-s2>=t)
{
rest=true;
time+=s;
}
//兔子休息了s秒(不包括s秒,第s秒开始行动,题目意思不是s秒之后)
if(rest&&start2-start1>=s)
{
//开始跑了(不休息)
rest=false;
}
//兔子不休息的时候跑
if(!rest)
{
start1++;
s1=v1*start1;
}
//乌龟总在跑
start2++;
s2=v2*start2;
//递归调用
race(v1,v2,t,s,l,start1,start2,s1,s2,time,rest);
}
}
publicstaticvoidmain(String[]args)
{
System.out.println("输入只有一行，包含用空格隔开的五个正整数v1，v2，t，s，l，"+
" 其中(v1,v2<=100;t<=300;s<=10;l<=10000且为v1,v2的公倍数)"+
" 退出输入n/N,否则继续:");
Scannerscanner=newScanner(System.in);
Stringline=null;
Stringreg="^([1-9]\d*|\d)\s+([1-9]\d*|\d)\s+([1-9]\d*|\d)\s+([1-9]\d*|\d)\s+([1-9]\d*|\d)$";
while(scanner.hasNextLine())
{
line=scanner.nextLine().trim();
if("n".equalsIgnoreCase(line))
{
break;
}
if(!line.matches(reg))
{
System.err.println("输入不对,重新输入:");
}
else
{
String[]input=line.split("\s+");
intv1=Integer.parseInt(input[0]);
intv2=Integer.parseInt(input[1]);
intt=Integer.parseInt(input[2]);
ints=Integer.parseInt(input[3]);
intl=Integer.parseInt(input[4]);
race(v1,v2,t,s,l,0,0,0,0,0,false);
System.out.println("退出输入n/N,否则继续:");
}
}
scanner.close();
}
}
❺ 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[0] + "|" + seperators[1];
}else{
regex = "" + seperators[0];
}
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(int[]arr) { 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(String[]args) { 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(int[]arr) { 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(String[]args) { 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简单算法问题
初步做了一个出来，但是效率并不是很高，前100个计算速度还可以，但是往后就很慢了。如果什么时候有空的话可以再看看，先给你代码吧，不知道能不能帮上你
publicclassAlisandaNumber{
privatestaticfinalintMAX_INDEX=1000;//可以先把这个常量改为1-6，验证正确性
publicstaticvoidmain(String[]args){
inta=0;
intindex=0;
while(index<MAX_INDEX){
a+=6;//每次循环自增6，由题目规律可知A是6的倍数
booleanbreakOut=false;
//最大的约数为此数的平方根，因为如果是两个平方根相乘的话，剩下的就只有1了
intmaxNum=(int)Math.ceil(Math.sqrt(a));
p:
for(intp=1;p<=maxNum;p++){
if(a%p!=0){
continue;//如果不是约数的话，没必要考虑，下同
}
//最大约数为平方根的相反数，原理同上
maxNum=(int)Math.ceil(Math.sqrt(a/p));
for(intq=-1;q>=-maxNum;q--){//q和r必为负数
if(a%q!=0){
continue;
}
intr=a/(p*q);
intnonZero=p*q+p*r+q*r;
if(nonZero==0){
continue;
}
if((a==p*q*r)&&(a==(p*q*r)/(nonZero))){
index++;
breakOut=true;
breakp;//跳出外层循环
}
}
}
if(breakOut){
System.out.println(String.format("第%d个压力山大数是%d",index,a));
}
}
}
}❼ JAVA算法题目：int数组内取数相加凑数
首先观察数组可以排除几个数：588，4375，5184 因为他们如何相加也不会以0结尾。限于篇幅，部分代码如下，剩余的循环可以自己添加下，采用穷举法：
public class DoMain {
public void doit(){
int[] a = new int[] { 460, 720, 1250, 1800, 2200, 3080, 4100,
6510, 6900, 9000 };
for(int i1=0;i1<a.length;i1++){
for(int i2=i1+1;i2<a.length;i2++){
if(a[i1]+a[i2]==13750){
System.out.println(a[i1]+";"+a[i2]);
}
for(int i3=i2+1;i3<a.length;i3++){
if(a[i1]+a[i2]+a[i3]==13750){
System.out.println(a[i1]+";"+a[i2]+";"+a[i3]);
}
for(int i4=i3+1;i4<a.length;i4++){
if(a[i1]+a[i2]+a[i3]+a[i4]==13750){
System.out.println(a[i1]+";"+a[i2]+";"+a[i3]+";"+a[i4]);
}
for(int i5=i4+1;i5<a.length;i5++){
if(a[i1]+a[i2]+a[i3]+a[i4]+a[i5]==13750){
System.out.println(a[i1]+";"+a[i2]+";"+a[i3]+";"+a[i4]+";"+a[i5]);
}
for(int i6=i5+1;i6<a.length;i6++){
if(a[i1]+a[i2]+a[i3]+a[i4]+a[i5]+a[i6]==13750){
System.out.println(a[i1]+";"+a[i2]+";"+a[i3]+";"+a[i4]+";"+a[i5]+";"+a[i6]);
}
for(int i7=i6+1;i7<a.length;i7++){
if(a[i1]+a[i2]+a[i3]+a[i4]+a[i5]+a[i6]+a[i7]==13750){
System.out.println(a[i1]+";"+a[i2]+";"+a[i3]+";"+a[i4]+";"+a[i5]+";"+a[i6]+";"+a[i7]);
}
}
}
}
}
}
}
}
}
public static void main(String[] args) {
DoMain main= new DoMain();
main.doit();
}}