算法题

一些简单的算法，本人的想法，如有更好的解决办法欢迎留言，谢谢

1、计算某两个数之间的素数

素数：只能被1和本身整除的整数。

/**
 * 计算素数
 * @author dell
 *
 */
public class Test1 {
	public static void main(String[] args) {
		getSushu(1,200);
	}

	private static void getSushu(int a, int b) {
		int count = 0;
		for(int i=a; i<=b; i++){
			for(int m=2; m<i; m++){
				if(i%m==0){//整除
					break;
				}
				if(m==(i-1)){
					System.out.println("素数："+i);
					count++;
				}
			}
		}
		System.out.println("共有"+count+"个素数");
		
	}
}

2、条件运算符的使用

/**
 * 利用条件运算符的嵌套来完成此题：学习成绩> =90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。
 * a>b?a:b
 * @author dell
 *
 */
public class Test2 {
	public static void main(String[] args) {
		System.out.println(getGradeClass(90));
	}
	
	public static String getGradeClass(double a){
		return a>=60?(a>=90?"A":"B"):"C";
	}
}

3、数组的倒叙遍历

/**
 * hello this is a computer-->computer a is this hello
 * 思路：用split分成数组，反向便利数组正向插入新的数组，再遍历输出
 * @author dell
 *
 */
public class Test4 {
	public static void main(String[] args) {
		swap("hello this is a computer");
	}
	
	public static void swap(String str){
		String[] ss = str.split(" ");//hello,this,is,a,computer
		String[] swapStr = new String[ss.length]; 
		int j=0;
		for(int i=ss.length-1; i>=0; i--){
			swapStr[j]=ss[i];
			j++;
		}
		
		for(int i=0; i<swapStr.length; i++){
			if(i==0){
				System.out.print(swapStr[i]);
			}
			System.out.print(" "+swapStr[i]);
		}
	}
}

4、抽象出规律模型的能力

/**
 * 一元钱一瓶汽水，喝完后两个空瓶换一瓶汽水。问：你有n元钱，最多可以喝到几瓶汽水？
 * 比如4元钱，可以喝7瓶
 * 瓶子				可以换几瓶
 * 1					0
 * 2					1
 * 3					2
 * 4					3
 * 5					4
 * 分析
 * 几块钱			喝到几瓶
 * 1				1
 * 2				2+1=3
 * 3				3+2=5
 * 4				4+3=7
 * 5				5+4=9
 * 结果
 * num=n+(n-1)=2n-1
 * @author dell
 *
 */
public class Test5 {
	public static void main(String[] args) {
		int n=20;
		System.out.println(n+"块钱可以喝到"+getDrinckNum(n)+"瓶");
	}
	
	public static int getDrinckNum(int money){
		return 2*money-1;
	}
}

5、String一些用法

/**
 * 编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串，但是要保证汉字不被截半个，
 * 如“我ABC”4，应该截为“我AB”，输入“我ABC汉DEF”6，应该输出为“我ABC”，而不是“我ABC+汉的半个”
 * 分析：先转换成byte[],判断截取的最后一位是不是汉字(byte[i]<0);如果是汉字就截取到前一位；如果不是就全部截取
 * @author dell
 */
public class Tets7 {
	public static void main(String[] args) {
		String str = "我我ABC汉DEF";
		System.out.println(splitString(str, 6));
	}

	private static String splitString(String str, int index) {
		if(str==null){
			return null;
		}
		byte[] bb = str.getBytes();
		int len = bb.length;
		if(index>len){
			index = len;
		}
		
		String s = "";
		if(bb[index]<0){	//汉字
			s = new String(bb, 0, index-1);
		}else{
			s = new String(bb, 0, index);
		}
		return s;
	}
}

6、String的一些操作

/*
 * 【字符串相关算法题】 
 * 1.字符串反转 
 * 2.判断两个字符串是否由相同的字符组成 
 * 3.删除字符串中重复的字符 
 * 5.统计一行字符里有多少单词 
 */
public class TestString {
	public static void main(String[] args) {
//		System.out.println("1.字符串反转:"+getConvetString1("1.字符串反转"));
//		System.out.println("1.字符串反转:"+getConvetString2("字符串反转"));
//		System.out.println("1.字符串反转:"+getConvetString3("字符串反转"));
//		System.out.println("2.判断两个字符串是否由相同的字符组成 :"+isEqual("String","String"));
//		System.out.println(deleteSame("aaaaA"));
//		System.out.println(getWordNum("danci nia hao a "));
		
	}
	
	/**
	 * 1.字符串反转（方法一）
	 * @param str
	 * @return
	 */
	public static String getConvetString1(String str){
		StringBuffer sb = new StringBuffer();
		sb.append(str);//append同步的方法，修改的时候不允许其他线程进行修改
		return sb.reverse().toString();//reverse是synchronized方法
	}
	
	/**
	 * 1.字符串反转（方法二）
	 * @param str
	 * @return
	 */
	public static String getConvetString2(String str){
		if(str==null){
			return null;
		}
		char[] strchar = str.toCharArray();
		int k=0;
		char[] resultChar = new char[strchar.length];
		for(int i=strchar.length-1; i>=0; i--){
			resultChar[k]=strchar[i];
			k++;
		}
		
		return String.valueOf(resultChar);
	}
	
	/**
	 * 方法三：StringBuffer反转的方法
	 * @param str
	 * @return
	 */
	public static String getConvetString3(String str) {
		char[] cstr = str.toCharArray();
		int num = cstr.length>>1;//需要循环几遍。右移，相当于除以2。位操作更快。
		for (int i = 0; i < num; i++) {
			char tmp1 = cstr[i];
			char tmp2 = cstr[str.length()-i-1];
			cstr[i] = tmp2;
			cstr[str.length()-i-1] = tmp1;
		}
		
		return String.valueOf(cstr);
	}
	
	
	/**
	 * 2.判断两个字符串是否由相同的字符组成
	 * a=String
	 * b=String
	 */
	public static boolean isEqual(String a, String b){
		boolean flag = false;
		if(a==null && b==null){
			flag = true;
		}
		if(a!=null&&b!=null){
			char[] achar = a.toCharArray();
			char[] bchar = b.toCharArray();
			if(achar.length==bchar.length){
				for(int i=0; i<achar.length; i++){
					if(achar[i]!=bchar[i]){
						return false;
					}
				}
				flag = true;
			}
		}
			
		return flag;
	}
	
	/**
	 * 3.删除字符串中重复的字符 
	 * Stringt
	 */
	public static String deleteSame(String str){
		char[] cstr = str.toCharArray();
		String result = "";
		for(char item: cstr){
			if(result.contains(String.valueOf(item))){
				continue;
			}
			result+=item;
		}
		return result;
	}
	
	/**
	 * 4.统计一行字符里有多少单词 
	 * You are my everything.
	 */
	public static int getWordNum(String str){
		String trimStr = str.trim();
		String[] ss = str.split(" ");
		return ss.length;
	}
}

7、递归算法

/*
 * 汉诺塔问题
 */
public class HanoiTest {
	public static void main(String[] args) {
		int desks = 3;
		move(desks, "A", "B", "C");
	}
	/**
	 * A->B,A->C,B->C
	 * 到一个盘子的时候直接移动
	 * @param desks几个盘子
	 * @param from从哪个柱子
	 * @param inner过渡柱子
	 * @param to到哪个柱子
	 */
	private static void move(int desks, String from, String inner, String to) {
		if(desks==1){
			System.err.println("第"+desks+"个盘子从"+from+"移到"+to);
		}else{
			move(desks-1, from, to, inner);//A->B(from->temp)
			System.out.println("第"+desks+"个盘子从"+from+"移到"+to);//A->C(正式)
			move(desks-1, inner, from, to);//B->C(temp->to)
		}
	}
}