`
mengqingyu
  • 浏览: 332988 次
  • 性别: Icon_minigender_1
  • 来自: 天津
社区版块
存档分类
最新评论

Java常用算法

阅读更多
/**
 * 类功能描述:常用算法
 */
public class Arithmetic {
	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		{
			System.out.println("请输入2个数");
		    int a = Integer.parseInt(in.readLine());
		    int b = Integer.parseInt(in.readLine());
			if(b > a) {
				int temp = a;
				a = b;
				b = temp;			
			}
			int dv = divisor(a, b);
			System.out.println("最大公约数:" + dv);
			int gb = gbs(a, b);
			System.out.println("最小公倍数:" + gb);
		}
		
		{
			int result = 1;
			System.out.println("阶乘:请输入数字");	
			int n = Integer.parseInt(in.readLine());
			result = recursion(n, result);
			System.out.println("结果为:" + result);
		}
		
		{		
			System.out.println("查找字符串匹配个数");
			System.out.println("请输入字符串:");
			String str = in.readLine();	
			System.out.println("请输入要查找的字符串:");
			String strToFind = in.readLine();
			System.out.println("结果为:" + countStr(str,strToFind));
		}
		
		{		
			System.out.println("请输入人民币金额");
			String rmb = in.readLine();	
			System.out.println("输入人民币金额为:" + rmbToConvert(rmb));
		}

		{		
			String str="6sabcsssfsfs33"; 
			System.out.println("原字符串:"+str);
			str = rmString(str);
			System.out.println("结果:" + str);
		}
	}
	
	//最大公约数
	public static int divisor(int a, int b) {
		if(a%b == 0) {
			return b;
		} else {
			return divisor(b, a%b);
		}		
	}
	
	//最小公倍数
	public static int gbs(int a, int b) {
		return a*b/divisor(a, b);
	}	
	
	//阶乘
	public static int recursion(int n, int result) {
		if (n> 0) {
			result = result * n;
			return recursion(n-1, result);
		}
		return result;
	}
	
	//查找字符串匹配个数
	public static int countStr(String str, String strToFind)  throws IOException {
		int count = 0;
		int index = -1;
		if(str.length() < strToFind.length()) {
			String temp = str;
			str = strToFind;
			strToFind = temp;
		}
		while((index = str.indexOf(strToFind)) != -1) {
			str = str.substring(strToFind.length() + index);
			count++;
		}
		if(count == 0) {
			throw new IOException("没有匹配");
		}
		return count;
	}
	
	//数字转换大写
	public static String rmbToConvert(String rmb)
	{
		final String []bitRmb = {"","十","百","千"};
		final String []bigRmb = {"","万","亿"};
		final String []numberRmb = {"0","1","2","3","4","5","6","7","8","9"};
		final String []hanRmb = {"零","一","二","三","四","五","六","七","八","九"};
		int i,j;
		for(i=0;i<hanRmb.length;i++){
			rmb = rmb.replaceAll(numberRmb[i], hanRmb[i]);
		}		
		StringBuilder sb = new StringBuilder();
		sb.append("元");
		for(i=rmb.length()-1,j=0;i>=0;i--,j++){
			char temp = rmb.charAt(i);
			if(temp!='零'){
				sb.append(bitRmb[j%4]); //添加单位
			}
			if(j%4==0){
				sb.append(bigRmb[j%3]); //添加单位
			}
			sb.append(temp);  
		}
		String result = sb.reverse().toString(); //逆序处理方法
		result = result.replaceAll("零*", "");
		return result;
	}
	
	//删除字符串ab3
	public static String rmString(String str)
	{
		boolean[] removeChars = new boolean[256];   
		removeChars['a'] = true;   
		removeChars['b'] = true;   
		removeChars['3'] = true;   
		StringBuffer sb = new StringBuffer();   
		for (char ch:str.toCharArray()) {   
			if (!removeChars[ch]) sb.append(ch);   
		}   
		return sb.toString();   
	}
	
	//读取文件中字符串判断其内容
	public static void readFile() throws IOException
	{
	    String fileName = "C:/Hello.txt"; 
		String line;
		int i,k = 0,cU = 0,cL = 0,cN = 0; 
		BufferedReader in = new BufferedReader(new FileReader(fileName)); 
		line = in.readLine();   //读取一行内容 
		while ( line != null ) {  
		    cU = 0 ; 
		    cL = 0 ; 
		    cN = 0 ; 
		    char c; 
			for(i=0 ;i<line.length();i++){
				c = line.charAt(i);
				if(c > 'a' && c < 'z') { 
					cL ++ ; 
				} 
				else if(c > 'A' && c < 'Z') { 
					cU ++ ; 
				} 
				else { 
					cN ++ ; 
				} 
			}
			line = in.readLine(); 
			k++ ;  
		 } 
		 System.out.println("Number of LowerCase:" + cL); 
		 System.out.println("Number of UpperCase:" + cU); 
		 System.out.println("Number of NotChar:" + cN); 
	}
}

/**
 * 类功能描述:多种排序算法,默认升序
 */
public class BaseSort {
	// 交换i1、i2下标指向的值
	public void swap(Object[] array, int i1, int i2) {
		Object tempObj;
		tempObj = array[i1];
		array[i1] = array[i2];
		array[i2] = tempObj;
		tempObj = null;
	}
	// 打印输出数组元素
	public void print(Object[] array) {
		for (Object obj : array) {
			System.out.print(obj + "    ");
		}
		System.out.println();
	}

	public static void main(String[] args) {
		System.out.println("----------------------------------------------------->插入排序");
		Object[] insertArray = { 9, 5, 7, 1, 6, 3, 8, 10, 4, 2 };
		(new InsertSort()).insertSort(insertArray);
		System.out.println("----------------------------------------------------->冒泡排序");
		Object[] bubbleArray = { 9, 5, 7, 1, 6, 3, 8, 10, 4, 2 };
		(new BubbleSort()).bubbleSort(bubbleArray);
	}
}

/**
	插入排序 将数组所有元素划分成了有序区和无序区,假设当前数组有 N 个元素,
	开始默认第一个元素(下标为0)所处的位置是有序区,这是局部有序,从第二个元素(i=1)至数组最后一个元素(i=N-1)属于无序区;
	假设数组元素是按从左至右存放的,如果用 i 来标记无序区中的第一个元素下标,也就是无序区中最左边或者说是无序区中下标值最小的下标,
	则每趟排序是将下标 i 所指向的有效值插入有序区的适当位置,使得每趟排序完成之后,有序区的所有元素总是保持局部有序状态。
	按这样来回 N -1 趟插入之后,则 N 个元素已成有序状态,复杂度O(n^2)
 */
class InsertSort extends BaseSort {
	/**
	 * @方法名: insertSort
	 * @参数名: array 排序对象
	 * @参数名: order 排序顺序
	 * @描述语: 插入排序:默认第一个是有序,使其余的像纸牌游戏那样依次插入,复杂度 O(n^2)
	 */
	public void insertSort(Object[] array) {
		int length = array.length;
		for (int i = 1, j; i < length; i++) { // 默认第1个(下标0)有序,i是无序区第一个元素下标,第i趟结束后,i下移,如此来回N -1趟
			for (j = 0; j < i; j++) { // 将无序区下标为i所指向的值插入有序区适当位置
				if (Double.parseDouble(array[j].toString()) > Double.parseDouble(array[i].toString())) {
					swap(array, i, j);
				}
			}
			System.out.println("----------------------------------------------------->第" + i + "趟");
			print(array);
		}
	}
}

/**
	N 个元素数据需要进行 N - 1 趟排序,第 i 趟排序,需要对元素数据做两两比较 N - i 次
	,每趟排序完成之后,剩余较大的元素(升序)或较小的元素(降序)将冒到
	数组最末端,此后,该项元素就此排定,不需要再移动。
 */
class BubbleSort extends BaseSort {
	/**
	 * @方法名: bubbleSort
	 * @参数名: array 排序对象
	 * @参数名: order 排序顺序
	 * @描述语: 单向冒泡排序,复杂度:O(n^2)
	 */
	public void bubbleSort(Object[] array) {
		int length = array.length;
		for (int i = 0, j; i < length - 1; i++) { // N个数需N-1趟,每趟完成之后,较大元素将冒到数组最末端
			for (j = 0; j < length - 1 - i; j++) { // 每趟需要比较N-i次比较
				if (Double.parseDouble(array[j].toString()) > Double.parseDouble(array[j + 1].toString())) {
					swap(array, j, j + 1);
				}
			}
			System.out.println("----------------------------------------------------->第" + i + "趟");
			print(array);
		}
	}
}

/**
 * 
 * 类功能描述:路人甲攻击路人乙,假设结果只可能是:击中、击中要害、躲闪、招架这四种之一,并且只能是一种(为描述方便四种结果分别用符号A、B、C、D代表):
 * 假设这四种结果发生的概率分别是a%,b%,c%,d%,其中a+b+c+d=100,要求从这四种结果中随机选出一种结果,发生概率越高的事件被选中的几率越大。
 *			 
 * @author <a href="mailto:qingyu.meng21@gmail.com">mengqingyu </a>
 * @version $Id: codetemplates.xml,v 1.1 2009/03/06 01:13:01 mengqingyu Exp  $
 * Create:  2014-4-2 下午01:56:27
 */
public class Chances {
	
	/**
	 *	@function:根据概率随机选择一种结果,发生概率越高的事件被选中的几率越大
	 *	@param percents 参数数组的元素值分别顺序代表A,B,C,D发生的概率
	 *	@return 返回0代表A事件,返回1代表B事件,返回3代表D事件
	 *	 根据要求实现randomResult方法
	 */
	public int randomResult(int[] percents){
		int randomNumber = (int) (Math.random()*100);
		if (randomNumber >= 0 && randomNumber < percents[0]) {
			return 0;
		} else if (randomNumber >= percents[0] && randomNumber < percents[0] + percents[1]) {
			return 1;
		} else if (randomNumber >= percents[0] + percents[1] && randomNumber < percents[0] + percents[1] + percents[2]) {
			return 2;
		} else if (randomNumber >= percents[0] + percents[1] + percents[2] && randomNumber < percents[0] + percents[1] + percents[2] + percents[3]) {
			return 3;
		}
		return -1;
	}
	
	public static void main(String[] args) {
		Chances chances = new Chances();
		int[] percents = {5,10,30,55};
		int result = chances.randomResult(percents);
		System.out.println(result);
	}
}

import java.util.Random;

/**
 * 
 * 类功能描述:两个整数A和B,A的值范围为[0,255],B的值范围为[0,0xFFFFFF],为了节省存储空间,需要将它们压缩在一个int中,如何实现?又如何还原?请用JAVA代码编写。
 *
 * @author <a href="mailto:qingyu.meng21@gmail.com">mengqingyu </a>
 * @version $Id: codetemplates.xml,v 1.1 2009/03/06 01:13:01 mengqingyu Exp  $
 * Create:  2014-4-2 下午02:18:11
 */
public class Depress {

	/**
	 * 
	 * @function:
	 * @param random10   0-255 占用8位二进制
	 * @param random16   0-0xFFFFFF 占用24位二进制 
	 * @author: mengqingyu    2014-4-2 下午01:54:27
	 */
	public void bitShift(int random10, int random16) {
		int result = random10 << 24 | random16; // int类型是4个字节占用32位二进制,所以可以容纳以上2个数,低8位左移24位空出24位用来通过|存放16进制的24位
		System.out.println("原10进制数" + random10 + ":" + Integer.toBinaryString(random10));// 转换成二进制输出原数据
		System.out.println("原16进制数" + random16 + ":" + Integer.toBinaryString(random16));// 转换成二进制输出原数据
		System.out.println("存到一个int中:" + Integer.toBinaryString(result)); // 转换成二进制输出最终结果
		System.out.println("取出10进制数" + random10 + ":" + Integer.toBinaryString(result >>> 24)); // 右移24位还原10进制数,用>>>为了高位补0,
		System.out.println("取出16进制数" + random16 + ":" + Integer.toBinaryString(result << 8 >>> 8)); // 先左移8位为了把10进制数清零,剩下24位的16进制在右移8位还原
	}

	public static void main(String[] args) {
		Random random = new Random(); // 随机数
		Depress depress = new Depress();
		depress.bitShift(random.nextInt(255), random.nextInt(Integer.valueOf("FFFFFF", 16)));
	}
}

/**
 * 
 * 类功能描述:以下String类用于存储字符串,假设其实现如下:
 * 			  请完整实现其equals方法和hashCode方法(为了提高性能可以增加私有成员变量)。
 * 			  根据要求实现equals和hashCode方法
 * @author <a href="mailto:qingyu.meng21@gmail.com">mengqingyu </a>
 * @version $Id: codetemplates.xml,v 1.1 2009/03/06 01:13:01 mengqingyu Exp  $
 * Create:  2014-4-2 下午02:07:28
 */
public final class Sstring {

	/** 用于存储字符串的数组,字符串存储总是从第一个开始 */
	private final char value[];

	/** 指示存储的字符总数  */
	private final int count;

	private final int offset = 0;

	private int hash;

	public Sstring(char value[], int count) {
		this.value = value;
		this.count = count;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if ((obj == null) || (obj.getClass() != this.getClass()))
			return false;
		if (obj instanceof Sstring) {
			Sstring anotherString = (Sstring) obj;
			int n = count;
			if (n == anotherString.count) {
				char v1[] = value;
				char v2[] = anotherString.value;
				int i = offset;
				int j = anotherString.offset;
				while (n-- != 0) {
					if (v1[i++] != v2[j++])
						return false;
				}
				return true;
			}
		}
		return false;
	}

	//HashCode遵循原则,一般使用较小素数作为系数如31,来进行乘法计算这样能够最大限度降低地址重复率和超出int范围
	@Override
	public int hashCode() {
		int h = hash;
		if (h == 0 && value != null) {
			int off = offset;
			char val[] = value;
			int len = count;
			for (int i = 0; i < len; i++) {
				h = 31 * h + val[off++];
			}
			hash = h;
		}
		return h;
	}

	public static void main(String[] args) {
		char value[] = { '1', '2', '3' };
		int count = 3;
		Sstring s1 = new Sstring(value, count);
		Sstring s2 = new Sstring(value, count);
		System.out.println(s1.hashCode());
		System.out.println(s2.hashCode());
		System.out.println(s1.equals(s2));
	}
}

/**
 * 
 * 类功能描述:游戏世界中使用技能攻击目标时,攻击结果可能是:击中、暴击、躲闪、招架四种之一,这些攻击结果被定义为常量,如下:
 * 			   在战斗系统的处理过程中,这些攻击结果会出发相应的事件。	
 * 			   要求:根据给定的攻击结果和给定的事件,判断指定的事件是否被触发,用效率最高的实现以下eventFired方法。
 * @author <a href="mailto:qingyu.meng21@gmail.com">mengqingyu </a>
 * @version $Id: codetemplates.xml,v 1.1 2009/03/06 01:13:01 mengqingyu Exp  $
 * Create:  2014-4-2 下午02:03:04
 */
public class WorldGame {

	enum ResultFlag {
		HIT, /**击中*/
		CRITICAL, /**暴击*/
		DODGE, /**躲闪*/
		PARRY /**招架*/
	}

	enum EventFlag {
		ON_HIT, /**击中时,HIT被触发*/
		ON_BE_HIT, /**被击中时,HIT被触发*/
		ON_HIT_CRITICALLY, /**暴击时,CRITICAL被触发*/
		ON_BE_HIT_CRITICALLY, /**被暴击时,CRITICAL被触发*/
		ON_DODGE, /**躲闪时,DODGE被触发*/
		ON_BE_DODGED, /**被躲闪时,DODGE被触发*/
		ON_PARRY, /**招架时,PARRY被触发*/
		ON_BE_PARRIED /**被招架时,PARRY被触发*/
	}

	public boolean eventFired(ResultFlag result, EventFlag event) {
		//Enum.valueOf(enumType, name)
		switch(result.ordinal()){
			case 0:return (event==EventFlag.ON_HIT||event==EventFlag.ON_BE_HIT);
			case 1:return (event==EventFlag.ON_HIT_CRITICALLY||event==EventFlag.ON_BE_HIT_CRITICALLY);
			case 2:return (event==EventFlag.ON_DODGE||event==EventFlag.ON_BE_DODGED);
			case 3:return (event==EventFlag.ON_PARRY||event==EventFlag.ON_BE_PARRIED);
			default: return false;
		}
	}

	/**
	 * @function:
	 * @param args
	 * @author: mengqingyu 2014-3-26 下午03:46:24
	 */
	public static void main(String[] args) {
		WorldGame wg = new WorldGame();
		boolean flag1 = wg.eventFired(ResultFlag.HIT, EventFlag.ON_BE_HIT);
		boolean flag2 = wg.eventFired(ResultFlag.HIT, EventFlag.ON_BE_PARRIED);
		System.out.println("ResultFlag.HIT, EventFlag.ON_BE_HIT result:"+flag1);
		System.out.println("ResultFlag.HIT, EventFlag.ON_BE_PARRIED result:"+flag2);
	}
}


分享到:
评论

相关推荐

    Java常用算法手册(jb51.net)_Java常用算法手册_

    《Java常用算法手册》是一本面向Java初学者的算法指南,旨在通过深入浅出的方式,帮助读者理解并掌握各种常见的编程算法,从而提高他们的编程能力和解决问题的效率。这本书的覆盖范围广泛,涉及到算法基础、数据结构...

    Java常用算法手册

    资源名称:Java常用算法手册内容简介:现代的设计任务大多通过计算机编程来完成,而算法起到了至关重要的作用。可以毫不夸张地说,算法是一切程序设计的灵魂和基础。选择合理的算法,可以起到事半功倍的效果。 赵...

    Java常用算法手册 高清

    《Java常用算法手册》是一本深入探讨Java编程中常见算法的实用指南,旨在帮助开发者提升在实际工作中解决复杂问题的能力。...通过阅读这本书,你可以系统地学习和实践Java中的算法,为你的职业生涯增添更多的可能。

    java常用算法大全源代码.zip

    通过阅读这些源代码,不仅可以学习到如何在Java中实现各种算法,还能了解到如何优化代码性能,提升解决问题的能力。此外,这些源代码也可以作为实际项目中的参考,帮助开发者快速解决遇到的计算问题。 总的来说,这...

    Java常用算法手册.pdf

    根据提供的文件信息,“Java常用算法手册.pdf”似乎是一份针对Java程序员的学习资源,旨在帮助他们掌握和提升在算法方面的知识与技能。然而,基于提供的简短描述和部分内容来看,并没有直接涉及具体的算法知识点,...

    java常用算法手册源码

    本资源是“Java常用算法手册”的源代码,可以帮助开发者深入理解并实践各种常见的算法。 算法是解决问题或执行任务的精确步骤序列,是计算机科学的基础。对于Java开发者来说,掌握基本的算法知识不仅可以提高编程...

    《Java常用算法手册》源代码

    《Java常用算法手册》源代码是一份非常宝贵的资源,它为Java开发者提供了丰富的算法实现,是学习和实践算法的理想材料。这份源代码集合涵盖了多种经典和实用的算法,旨在帮助开发者提升编程技能,理解算法原理,并能...

    Java常用算法手册源码

    这本"Java常用算法手册源码"集合了Java编程中常见的算法实现,对于学习和提升Java算法能力非常有帮助。以下将对其中涉及的主要算法进行详细介绍: 1. 排序算法: - 冒泡排序:基础排序算法,通过不断交换相邻元素...

    java常用算法手册

    《Java常用算法手册》是一本深入浅出的编程资源,主要涵盖了Java编程语言中的各种常见算法,对于学习和提升Java编程技巧以及理解算法思想具有重要价值。这份手册以实际可运行的代码为载体,使读者能够直观地看到算法...

    Java常用算法手册源代码(第三版-宋娟)

    在Java中,数组提供了快速访问和定位元素的能力。 - **链表**:非连续存储的数据结构,每个元素(节点)包含数据和指向下一个节点的引用。分为单链表、双链表和循环链表等。 - **栈**:后进先出(LIFO)的数据结构...

    java常用算法手册第三版高清版

    java常用算法手册第三版高清版

    Java常用算法手册源代码

    3.1 常用算法思想概述 3.2 穷举算法思想 3.2.1 穷举算法基本思想 3.2.2 穷举算法实例 3.3 递推算法思想 3.3.1 递推算法基本思想 3.3.2 递推算法实例 3.4 递归算法思想 …… 第2篇 算法应用篇 第4章 排序算法 第5章 ...

    java常用算法手册源代码

    Java算法手册源代码包含了丰富的编程实践,是学习和理解算法的宝贵资源。这些源文件分别命名为P1到P13,可能代表着不同的章节或者主题。下面将针对Java算法这一主题,详细阐述一些重要的知识点。 首先,Java作为一...

Global site tag (gtag.js) - Google Analytics