Java算法之字符串反转分析

简介: 本文来自http://blog.csdn.net/liuxian13183/ ,引用必须注明出处! 在基本的工作内容开发中,算法不会显得那么重要,而在百万级别的时候,差距非常大,今天带大家研究下常见的字符串反转算法。



本文来自http://blog.csdn.net/liuxian13183/ ,引用必须注明出处!


在基本的工作内容开发中,算法不会显得那么重要,而在百万级别的时候,差距非常大,今天带大家研究下常见的字符串反转算法。

public class StringReverse {
	public static String reverse1(String orig) {
		char[] s = orig.toCharArray();
		int n = s.length - 1;
		int halfLength = n / 2;
		for (int i = 0; i <= halfLength; i++) {// 2分法+替换算法
			char temp = s[i];
			s[i] = s[n - i];
			s[n - i] = temp;
		}
		return new String(s);
	}

	public static String reverse2(String s) {// 2分法+异或算法 
		char[] str = s.toCharArray();
		int begin = 0;
		int end = s.length() - 1;
		while (begin < end) {
			str[begin] = (char) (str[begin] ^ str[end]);
			str[end] = (char) (str[begin] ^ str[end]);
			str[begin] = (char) (str[end] ^ str[begin]);
			begin++;
			end--;
		}
		return new String(str);
	}

	public static String reverse3(String s) {// jdk提供
		return new StringBuffer(s).reverse().toString();
	}

	public static String reverse4(String s) {// 2分递归算法
		int length = s.length();
		if (length <= 1)
			return s;
		String left = s.substring(0, length / 2);
		String right = s.substring(length / 2, length);
		return reverse1(right) + reverse1(left);
	}

	public static String reverse5(String s) {// 傳統从后往前加
		int length = s.length();
		String reverse = "";
		for (int i = 0; i < length; i++)
			reverse = s.charAt(i) + reverse;
		return reverse;
	}

	public static String reverse6(String s) {//傳統與5雷同
		char[] array = s.toCharArray();
		String reverse = "";
		for (int i = array.length - 1; i >= 0; i--)
			reverse += array[i];
		return reverse;
	}

	public static String reverse7(String s) {// 利用栈先进后出的特性
		char[] str = s.toCharArray();
		Stack<Character> stack = new Stack<Character>();
		for (int i = 0; i < str.length; i++)
			stack.push(str[i]);
		String reversed = "";
		for (int i = 0; i < str.length; i++)
			reversed += stack.pop();
		return reversed;
	}

	public static void main(String[] args) {
		String str = "hello world !";
		int length = 10000000;
		long curTime = System.currentTimeMillis();
		for (int i = 0; i < length; i++) {
			reverse1(str);
		}
		System.out.println("reverse1:" + (System.currentTimeMillis() - curTime));
		curTime = System.currentTimeMillis();
		for (int i = 0; i < length; i++) {
			reverse2(str);
		}
		System.out.println("reverse2:" + (System.currentTimeMillis() - curTime));
		curTime = System.currentTimeMillis();
		for (int i = 0; i < length; i++) {
			reverse3(str);
		}
		System.out.println("reverse3:" + (System.currentTimeMillis() - curTime));
		curTime = System.currentTimeMillis();
		for (int i = 0; i < length; i++) {
			reverse4(str);
		}
		System.out.println("reverse4:" + (System.currentTimeMillis() - curTime));
		curTime = System.currentTimeMillis();
		for (int i = 0; i < length; i++) {
			reverse5(str);
		}
		System.out.println("reverse5:" + (System.currentTimeMillis() - curTime));
		curTime = System.currentTimeMillis();
		for (int i = 0; i < length; i++) {
			reverse6(str);
		}
		System.out.println("reverse6:" + (System.currentTimeMillis() - curTime));
		curTime = System.currentTimeMillis();
		for (int i = 0; i < length; i++) {
			reverse7(str);
		}
		System.out.println("reverse7:" + (System.currentTimeMillis() - curTime));
	}
}


其他有趣的算法:
如赛马问题,25匹马,5个赛道,如何在不用工具的情况下,找到最快的5匹。问题可以简化为3匹马,3个赛道。
分A B C三组马,各赛一场,结果如下:
A1 A2 A3
B1 B2 B3
C1 C2 C3
3场第1名赛一场,得出第1名
如果是A1,则A2跟B1和C1比1场,其他同理,找出第2名
如果是B1,则A2跟B2和C1比1场,其他同理,找出第3名
比赛结束,共需要6场
同理可算出,25匹马需要10场。
如运煤问题,3000吨煤,用载重1000吨的火车,从原点运往终点,路程1000公里,每公里消耗1吨煤,到终点时煤剩几何?
粗略一算,第一种方案:
第一轮,
第1次,先拉1000吨到A,卸下500吨,返回,行程250公里
第2次,再拉1000吨到A,卸下500吨,返回,行程250公里,同理第三次
第3次后,A地剩下1500吨煤,行程250公里
第二轮
继续第4次,同上,到B地行程187.5公里,每次卸下375吨货物
两轮后,行程437.5公里,剩下货物750吨
第三轮
一次性运到,共剩余312.5吨
分析:由于第三轮每次只运750吨,运量未满,导致最终运送较少。
粗略一算,第二种方案:
第1次,先拉1000吨到A, 卸下500吨 行程250公里 ,返回
第2次,再拉1000吨到A,加上250吨满载,剩下250吨;走250公里到B,卸下250吨,总行程250公里,返回
第3次,再拉1000吨到A,加上250吨满载;再走250公里到B,加上前两次剩下的共500吨,满载1000吨继续
直行到终点,共剩余 500吨
分析:似乎比较完美,每次都是满载。
粗略一算,第三种方案:
变下思路,将此题变成n千吨煤,可以走多少公里,即消耗多少
那么1000吨走1000公里,2000吨运两次,向前3次向后2次,向前只能多走1/3公里,即1000*(1+1/3)公里,
同理可得3000吨走1000*(1+1/3+1/5)公里,n千吨可走1000*(1+1/3+1/5+……+1/(2n-1))公里
那么3000公里剩余多少呢?前两句已经讲了3000吨可走的公里,每公里1吨,多出多少公里即多出多少吨
1000*(1+1/3+1/5)-1000=1600/3吨,即533.33吨。功夫不负有心人,这就是最终答案!






目录
相关文章
|
2月前
|
安全 Java 编译器
new出来的对象,不一定在堆上?聊聊Java虚拟机的优化技术:逃逸分析
逃逸分析是一种静态程序分析技术,用于判断对象的可见性与生命周期。它帮助即时编译器优化内存使用、降低同步开销。根据对象是否逃逸出方法或线程,分析结果分为未逃逸、方法逃逸和线程逃逸三种。基于分析结果,编译器可进行同步锁消除、标量替换和栈上分配等优化,从而提升程序性能。尽管逃逸分析计算复杂度较高,但其在热点代码中的应用为Java虚拟机带来了显著的优化效果。
78 4
|
25天前
|
SQL JSON Java
告别字符串拼接:用Java文本块优雅处理多行字符串
告别字符串拼接:用Java文本块优雅处理多行字符串
261 108
|
15天前
|
存储 Java Go
【Java】(3)8种基本数据类型的分析、数据类型转换规则、转义字符的列举
牢记类型转换规则在脑海中将编译和运行两个阶段分开,这是两个不同的阶段,不要弄混!
127 2
|
15天前
|
Java Go 开发工具
【Java】(9)抽象类、接口、内部的运用与作用分析,枚举类型的使用
抽象类必须使用abstract修饰符来修饰,抽象方法也必须使用abstract修饰符来修饰,抽象方法不能有方法体。抽象类不能被实例化,无法使用new关键字来调用抽象类的构造器创建抽象类的实例。抽象类可以包含成员变量、方法(普通方法和抽象方法都可以)、构造器、初始化块、内部类(接 口、枚举)5种成分。抽象类的构造器不能用于创建实例,主要是用于被其子类调用。抽象类中不一定包含抽象方法,但是有抽象方法的类必定是抽象类abstract static不能同时修饰一个方法。
149 1
|
26天前
|
运维 监控 JavaScript
基于 Node.js 图结构的局域网设备拓扑分析算法在局域网内监控软件中的应用研究
本文探讨图结构在局域网监控系统中的应用,通过Node.js实现设备拓扑建模、路径分析与故障定位,提升网络可视化、可追溯性与运维效率,结合模拟实验验证其高效性与准确性。
156 3
|
7天前
|
存储 人工智能 算法
从零掌握贪心算法Java版:LeetCode 10题实战解析(上)
在算法世界里,有一种思想如同生活中的"见好就收"——每次做出当前看来最优的选择,寄希望于通过局部最优达成全局最优。这种思想就是贪心算法,它以其简洁高效的特点,成为解决最优问题的利器。今天我们就来系统学习贪心算法的核心思想,并通过10道LeetCode经典题目实战演练,带你掌握这种"步步为营"的解题思维。
|
1月前
|
数据采集 存储 弹性计算
高并发Java爬虫的瓶颈分析与动态线程优化方案
高并发Java爬虫的瓶颈分析与动态线程优化方案
|
24天前
|
存储 边缘计算 算法
【太阳能学报EI复现】基于粒子群优化算法的风-水电联合优化运行分析(Matlab代码实现)
【太阳能学报EI复现】基于粒子群优化算法的风-水电联合优化运行分析(Matlab代码实现)
|
3月前
|
自然语言处理 Java Apache
在Java中将String字符串转换为算术表达式并计算
具体的实现逻辑需要填写在 `Tokenizer`和 `ExpressionParser`类中,这里只提供了大概的框架。在实际实现时 `Tokenizer`应该提供分词逻辑,把输入的字符串转换成Token序列。而 `ExpressionParser`应当通过递归下降的方式依次解析
258 14