生活中存在一种误区，一些事情短时间内看不到收益的时候，不愿去做或难以坚持。如同投资股票市场，总是盯着短线走势，对于自身的规划，存在着许多短视的看法和行为，等到秋季大家都去菜园摘果实的时候，就可以看出当初谁没有好好开垦与播种了。

人生中不断的出现一些危机，当一个危机来临时，我们可能可以去全力以赴解决掉它，但是当危机如同破屋偏遭连夜雨般的到来，恐怕我们将难以去承受了，我们或许会像崇祯皇帝一样，面临着内忧外患之时，去拆东墙补西墙的挣扎为之，但是更需要思考的是，如何避免这种境遇，其实我们都是知道的，因为那些早就在一言一行中铺垫了。

或许，我想，有时候的痛苦是一种视角，就如同，我们总是着眼于短线，当短线的陡降或陡升，会让我们痛苦不已或欣喜若狂，倘若放眼更长远，着短线的波动，将会被平衡与稀释。

坚持是一件很困难的事情，当却又是很聪明的一种做法，因为我们是在努力的将一个十分的困难的事情转化为每天的一点点小困难。中断却又是可怕的，因为真可能将会抹杀掉之前的积累。就是因为那一次的中断，导致随后的次次的中断，导致现在提起笔来是那么的沉重，而在这沉默期，Google Reader 订阅居然上了100，许些惭愧。

放眼2011，自我的感觉是相对幸运的，在一个平静期，却又是在一个巨大的转型期，赢得了机遇，也将迎接新的挑战。

而2012没有奇迹，除非，从现在开始播种。

猜您也喜欢：
嗜睡的旅行者	四月番番	人生如传奇	TF-IDF统计
来自无觅网络的相关文章：
我的阿里框架升级项目总结（谈体验优化与用户习惯的延续） (@yixieshi)	2010 年互联网概况总结 (@netoearth)	QQ2012 Beta 1发布 (@netoearth)	美国YP iPad 软件设计经验分享 (@yixieshi)
无觅

相关文章

• 四月番番(0)
• 嗜睡的旅行者(0)

最近评论

《浪潮之巅》是Google的研究院吴军写的，Google黑板报中著名的连载《数学之美》也是他写的，对做数据挖掘，自然语言处理入门很有帮助，他写东西的特点是能将那些深奥的东西通过浅显易懂的方式让人理解与易于接受，比教科书中那些枯涩的公式概念更能让人快速入门与了解概况。

看了浪潮之巅，感受最深的就是一个转搞 IT的研究员居然知道这么多，而且很多是十分深刻有见解，知识面上下几百年，科学界，工业界，教育界，金融街，政府，等等，所谓读史使人明智，作为工科的人，虽然难以做到对人类文明发展史全面的了解，但是对近现在代科技历史发展历程，也是应该有一个全面的深刻的了解的，否则真的是生活工作在一片很小的树叶里，工科的学生真的就要一辈子甘愿做轮子了。

而吴军的这本书恰好比较内幕的全面的介绍了几大巨头科技公司的发展史，以及人类科技发展的一些规律现象，让人发现原来那些很高深诡异的企业原来是这样的，而那些很简单可能恰巧的事物背后原来暗藏着那么多的有趣的奥妙道理与博弈。同时还能读到很多科技界的奇闻趣事，比如motorola就是motor ola的连写，而是ola如同cola 是那是流行的后缀。

对于书中的内容，有几方面感受

1. 文中总结了计算机工业的生态链的几个定理，计算机硬件行业的 摩尔定理，与 反摩尔定理，决定的硬件行业的深刻的内在发展规律，通俗来说就是计算机硬件速度每18个月会翻一番（摩尔定理），如果一个IT公司今天和十八月前卖掉同样多的、同样的产品，它的营业额就要降一半（反摩尔定理）。

以及 安迪-比尔定理 则深刻的揭露了，硬件行业与软件行业的相互依赖与影响的规律。What Andy gives,Bill takes away (Andy 是原Intel CEO Andy Grove, Bill 就是 Microsoft 的Bill Gates了)，就是计算机软件会不断的吞噬掉计算机硬件的剩余，这个联系到今天的网络带宽也是一样的规律，人们日益活跃的网络带宽需求会吃掉每次网络带宽的增长，这样也就是带来的问题是今天中国的普遍 几兆的带宽决定中国互联网的什么样的生活。 硬件与软件应用的相辅相成的前进中，人民的科技生活也就随之不断的向前发展，当然这里不包括GFW。

以及第十四章中的，信息产业的规律性，70-20-10律 行业老大大二大三的份额稳态，诺威尔定理，公司市场占有率超过50%就决定了发展的饱和趋势，并决定了一个市场占有主导地位的公司必须不断的开拓新的财源，才能做到长盛不衰。以及可行的开拓的两种方式：Leverage现有的业务和转型。基因决定定理 则让我们发现连那些大型的企业都有一种不可忽视的思维定势。

2. 对IT科技与金融界的关系的探讨，通过一种标准型的IT科技公司创业史，在资本市场的操作下，通过天使投资，风险投资，IPO上市，每一次的融资，凭借资本的力量和巨大的杠杆左右，资本市场就在这每次的操作下进行十倍，百倍的扩增，创业者，早起员工，风险投资者的资本就这样一夜暴富；也进一步了解创业的各个环节问题，上市后长远利益与资本投资家的利益要求的矛盾，这才知道原来那些大公司其实都有很多苦不堪言的压力。

3. 关于一种的斯坦福大学的办学理念机制，与硅谷的相互发展与支持。以及对商业模式的探讨，什么样的模式才真的是一个商业的印钞机，创业需要考虑那些核心重要的因素。

决定在amazon买下这本书《浪潮之巅》看下最后几章节，也做下收藏。

猜您也喜欢：
生命之殇	推荐系统之协同过滤概述	Web2.0之Mashup初探	“园丁”的这几天
无觅

相关文章

• 0

最近评论

本文主要介绍hadoop基本入门概念，各实体含义及其作用。

并参考使用Hadoop 的版本r0.20.203.0，介绍简单集群部署入门，以及结合IDE开发入门实践。

Hadoop简介

Hadoop部署

#ip1# t1
#ip2# t2
#ip1# t3
#ip2# t4
#ip1# t5

<configuration>
     <property>
         <name>fs.default.name</name>
         <value>hdfs://t1:9000</value>
     </property>
</configuration>

<configuration>
     <property>
         <name>mapred.job.tracker</name>
         <value>t1:9001</value>
     </property>
</configuration>

<configuration>
     <property>
         <name>dfs.replication</name>
         <value>1</value>
     </property>
</configuration> 

开发&IDE环境

<dependency>
    <groupId>org.apache.mahout.hadoop</groupId>
    <artifactId>hadoop-core</artifactId>
    <version>0.20.203</version>
</dependency>

Hadoop MapReduce Framework入门，推荐程序WordCount：

http://wiki.apache.org/hadoop/WordCount

参考&资料推荐&下载：

• Hadoop in Action: http://ishare.iask.sina.com.cn/f/13834023.html
• Hadoop-The Definitive Guide: http://ishare.iask.sina.com.cn/f/13834271.html
• Hadoop 开发者入门专刊: http://ishare.iask.sina.com.cn/f/13617850.html

猜您也喜欢：
最佳实践-Java资源路径定位	Java应用程序打包-JarToExe	交叉验证	Windows常用shell命令大全
来自无觅网络的相关文章：
大象的崛起！Hadoop七年发展风雨录 (@netoearth)	Installing and Configuring Hadoop (@netoearth)	比Hadoop快11倍的分布式计算系统 (@netoearth)	Hadoop namenode HA方案 (@netoearth)
无觅

相关文章

• 0

最近评论

依然还记得四月份的几次吃饭，聊天之中才发现自己已经悄然成为一个现实的人，讨论未来几年实际而又无法逃避的问题，或许自己才是那个最为不安的人。

更加犹新的记得，在四五月交接的日子，忙碌殷时的学车以及准备着驾照考试，仿佛那是最后的一篇世外桃源，接下来面临的严酷的现实之前的一道避风港，专注的周围的人不所专注的，仿佛是生活在另一个世界，幸运的而又惊险的一次性通过桩考，内路与外路。当5月3号考完最后一门，在教室的等待的时候，却没有太多惊喜与冲动与领取那份任务性的结束宣告：驾照。突然发现，在学车的一个月里，已经习惯了周末奔向南五环，在那刚刚结束后的一两个周末里，显得是那么的无所适从与恐慌。再见吧508，再见吧，那些或阳光明媚微风徐徐或漫天灰蒙狂风凛冽的日子。

当期盼在翘首期待的之中被迎来之时，时光过得漫长而又短暂，行走在大街上，一种纯粹而唯一的想法是，一天之后、一周之后，还能够这样，把一些他人习以为常的都不知不觉的如获至宝对待，但正如所期待的一样，事情总是那么对称，想得到一面必须承受得起另一面。

对待有些事情的态度会在时间的飞逝下偶然之下得到完全彻底的改观，对于台球也是如此，偶然的试手，变发现这是一个不需要流汗的运动，不需要担心如游泳那样需要考虑当前体质状态问题，但却可以让心在那绿色的桌布上一路驰骋上一会儿。

也渐渐发现同一件事物不同人的态度也迥然有异，比如电影，也欣然看到不同的分析，如同透过背后发现不同的思维。然后发现有时候甚至自己的思维都难以掌控，变化莫测，曾经看完《最爱》后一大堆感想，想用笔端不写出从电影中的每一个场景发现导演的安排，用意，人情的悲喜剧，人性背后的一种独特而又有代表性的品行，以及所在环境下走向末路的必然。然而因为时间不是为想象中的安排，耽搁下后只剩下一堆或更深或以浅淡的感想不能言语般得沉淀。同样如此，翻看同导演顾长卫所拍的《孔雀》，时间久了，就只记得一个个的鲜明的性格以及一个时代的缩影了。

如今已经是拽着五月的尾巴了，一切所害怕的困难，是因为躲到虚幻的避风港值中，是因为不愿走过，却想跨过的沟壑，如果知道是跨不过的，那就悉心努力的走过吧。

猜您也喜欢：
vanjor almost	纪念下最近的几个第一次	年后回归	忙
无觅

相关文章

• 纪念下最近的几个第一次(2)
• 年后回归(4)
• Daily life using Google's(2)
• vanjor almost(1)
• 西红柿鸡蛋面(0)
• 忙(0)
• 来帝都的这些日子(0)

最近评论

• vanjor : (ˇˍˇ） ~
• olive : 忙碌而又丰富的生活~明天会更好~

一、概述

二、八大排序算法实现

package org.vanjor.sort;

public class BubbleSort implements Sorter {

	@Override
	public String getName() {
		return "BubbleSort";
	}

	@Override
	public void sort(int[] array) {
		int temp;
		for (int i = 0; i < array.length - 1; i++) {
			// 每次将最小的冒到最前面
			for (int j = array.length - 1; j > i; j--) {
				if (array[j - 1] > array[j]) {
					temp = array[j - 1];
					array[j - 1] = array[j];
					array[j] = temp;
				}
			}
		}
	}
}

package org.vanjor.sort;

public class InsertSort implements Sorter {

	@Override
	public String getName() {
		return "InsertSort";
	}

	@Override
	public void sort(int[] array) {
		int temp;
		int j;
		// i之前的子串都是已经排序好了
		for (int i = 1; i < array.length; i++) {
			j = i;
			temp = array[j];
			// 对当前位置j的数字在已排序好的子串选择合适的位置插入
			while (j > 0 && temp < array[j - 1]) {
				// 顺移直接存放
				array[j] = array[j - 1];
				j--;
			}
			// 选择到位置，直接存放归队
			array[j] = temp;
		}
	}

}

package org.vanjor.sort;

public class HalfInsertSort implements Sorter {
	@Override
	public String getName() {
		return "HalfInsertSort";
	}

	@Override
	public void sort(int[] array) {
		for (int i = 1; i < array.length; i++) {
			// 二分查找寻找最佳插入位置
			int low = 0, high = i - 1;
			while (low <= high) {
				int middle = (low + high) / 2;
				if (array[middle] > array[i]) {
					high = middle - 1;
				} else {
					low = middle + 1;
				}
			}
			// 顺移并插入
			int cursor = i;
			int temp = array[i];
			while (cursor > low) {
				array[cursor] = array[cursor - 1];
				cursor--;
			}
			array[cursor] = temp;
		}
	}
}

package org.vanjor.sort;

public class SelectSort implements Sorter {

	@Override
	public String getName(){
		return "SelectSort";
	}

	@Override
	public void sort(int[] array) {
		int cursor;
		int temp;
		for (int i = 0; i < array.length - 1; i++) {
			//通过比较选出最小值的游标，最后才交换
			cursor = i;
			for (int j = i + 1; j < array.length; j++) {
				if (array[j] < array[cursor]) {
					cursor = j;
				}
			}
			if(cursor!=i){
				temp = array[i];
				array[i] = array[cursor];
				array[cursor] = temp;
			}
		}

	}

}

package org.vanjor.sort;

public class QuickSort implements Sorter {

	@Override
	public String getName() {
		return "QuickSort";
	}

	@Override
	public void sort(int[] array) {
		if (array == null || array.length == 0) {
			return;
		}
		sort(array, 0, array.length - 1);
	}

	/**
	 * 递归式，对array中的start到end区域进行快排
	 *
	 * @param array
	 * @param start
	 * @param end
	 */
	private void sort(int[] array, int start, int end) {
		// 递归终止条件
		if (start >= end) {
			return;
		}

		int low = start;
		int high = end;
		// 选择当前子数组第一个数为旗帜
		int flag = array[low];
		while (low < high) {

			while (low < high && array[high] >= flag) {
				high--;
			}
			array[low] = array[high];

			while (low < high && array[low] <= flag) {
				low++;
			}
			array[high] = array[low];
		}
		// 此时low的位置为旗帜的最终正确位置
		array[low] = flag;

		// 递归对旗帜的两边进行排序，这是low=high
		sort(array, start, low - 1);
		sort(array, high + 1, end);
	}

}

package org.vanjor.sort;

public class ShellSort implements Sorter {

	@Override
	public String getName() {
		return "ShellSort";
	}

	@Override
	public void sort(int[] array) {
		int temp;
		int inc = array.length / 2;
		while (inc >= 2) {
			for (int cursor = 0; cursor <= array.length - 1 - inc; cursor++) {
				if (array[cursor] > array[cursor + inc]) {
					temp = array[cursor];
					array[cursor] = array[cursor + inc];
					array[cursor + inc] = temp;
				}

			}
			// 步长序列每次除2
			inc /= 2;
		}

		// 最后步长为1，知道检查无更改，即退出循环
		boolean tag = true;
		while (tag) {
			tag = false;
			for (int cursor = 0; cursor < array.length - 1; cursor++) {
				if (array[cursor] > array[cursor + 1]) {
					temp = array[cursor];
					array[cursor] = array[cursor + 1];
					array[cursor + 1] = temp;
					tag = true;
				}
			}
		}
	}
}

package org.vanjor.sort;

public class MergeSort implements Sorter {

	@Override
	public String getName(){
		return "MergeSort";
	}

	@Override
	public void sort(int[] array) {
		int[] tempArray = new int[array.length];
		mergeSort(array, tempArray, 0, array.length - 1);
	}

	/**
	 * 不断分割，再合并，递归求解
	 */
	private void mergeSort(int[] array, int[] tempArray, int start, int end) {
		// 递归终止条件，最终粒度为1
		if (end <= start) {
			return;
		}
		// 这里保证了start<=middle,middle+1<=end
		int middle = (start + end) / 2;
		// 从middle分两部分，每一部分排序后，再合并排序
		mergeSort(array, tempArray, start, middle);
		mergeSort(array, tempArray, middle + 1, end);
		// 合并
		merge(array, tempArray, start, middle, end);
	}

	/**
	 * 将两个有序数据合并，两数组的位置分别为start->middle,middle+1->end
	 */
	private void merge(int[] array, int[] tempArray, int start, int middle,
			int end) {
		int pos1, pos2, mergePos;
		//将两相邻子数组合并到临时数据中
		for (pos1 = start, pos2 = middle + 1, mergePos = start; pos1 <= middle
				&& pos2 <= end; mergePos++) {
			if (array[pos1] > array[pos2]) {
				tempArray[mergePos] = array[pos2++];
			} else {
				tempArray[mergePos] = array[pos1++];
			}
		}
		//对剩余的部分直接复制
		while (pos1 <= middle) {
			tempArray[mergePos++] = array[pos1++];
		}
		while (pos2 <= end) {
			tempArray[mergePos++] = array[pos2++];
		}

		//将临时数据中按位置拷贝回
		int pos = start;
		while (pos <= end) {
			array[pos] = tempArray[pos];
			pos++;
		}

	}
}

package org.vanjor.sort;

public class HeapSort implements Sorter {
	@Override
	public String getName() {
		return "HeapSort";
	}

	public void sort(int[] array) {
		if (array == null || array.length < 2) {
			return;
		}
		int len = array.length - 1;

		// 从最底层非叶子节点开始建堆
		for (int i = (len) / 2; i >= 1; i--) {
			headAjust(array, i, len);
		}
		// 需要turnNum次取堆顶，获得全部排序
		int turnNum = len;
		// 当前轮次，堆顶，最大值
		int turnMax = array[1];

		// 因为array排序起点为1，所谓到1停止了
		while (turnNum >= 1) {
			array[1] = array[turnNum];
			array[turnNum] = turnMax;
			turnNum--;
			// 重建堆
			headAjust(array, 1, turnNum);
			// 得到新堆堆顶
			turnMax = array[1];
		}
	}

	public void headAjust(int[] array, int start, int end) {
		int cursor;
		// 保存当前顶点start值
		int local = array[start];
		for (cursor = 2 * start; cursor <= end; cursor *= 2) {
			// 取start的两个叶子节点中较大者，cursor为对应叶子节点序号
			if (cursor < end && array[cursor] < array[cursor + 1]) {
				cursor++;
			}
			// 如果顶节点就是最大，则无需继续调节了
			if (local >= array[cursor]) {
				break;
			}
			// 最大值上移到顶点
			array[start] = array[cursor];
			// 沿树向下继续建堆调整，其实也就是被替换下来的顶点找到位置
			start = cursor;
		}
		// 找到对应位置，归位
		array[start] = local;
	}
}

package org.vanjor.sort;

import java.util.ArrayList;
import java.util.LinkedList;

public class RadixSort implements Sorter {

	@Override
	public String getName() {
		return "RadixSort";
	}

	@Override
	public void sort(int[] array) {
		// 只是为了演示，基数所用桶，这里用高级链表API
		// 桶集A存放当前轮次开始前的状态
		ArrayList<LinkedList<Integer>> bucketA = new ArrayList<LinkedList<Integer>>();
		// 桶集B存放当前轮次排序后的状态
		ArrayList<LinkedList<Integer>> bucketB = new ArrayList<LinkedList<Integer>>();
		// 每轮次排序后颠倒后交换用
		ArrayList<LinkedList<Integer>> tempArray;
		// 基于数字排序，共10个桶
		final int bucketBase = 10;
		int temp = bucketBase;
		while ((--temp) >= 0) {
			bucketA.add(new LinkedList<Integer>());
			bucketB.add(new LinkedList<Integer>());
		}
		// 找出当前最大的数，用以确定最多需要桶装填的轮次
		int maxNum = -1;
		for (int i = 0; i < array.length; i++) {
			if (array[i] > maxNum) {
				maxNum = array[i];
			}
		}
		// 计算轮次
		int turn = 0;
		while (maxNum > 0) {
			turn++;
			maxNum /= bucketBase;
		}
		// 初始装填到A桶集中
		for (int i = 0; i < array.length; i++) {
			bucketA.get(array[i] % 10).add(array[i]);
		}
		int locNum;
		int turnBaseDiv = 1;
		while ((turn--) > 0) {
			// 当前轮次，对桶集中的10个桶按当前位进行重新状态
			for (int i = 0; i < bucketBase; i++) {
				while (!bucketA.get(i).isEmpty()) {
					locNum = bucketA.get(i).remove();
					// 根据当前轮次比较位，找到对应的桶
					bucketB.get((locNum / turnBaseDiv) % 10).add(locNum);
				}
			}
			// 比较位前移
			turnBaseDiv *= 10;
			// 交换A，B次序
			tempArray = bucketB;
			bucketB = bucketA;
			bucketA = tempArray;
		}
		// 从桶中顺序取数
		for (int i = 0, j = 0; i < 10; i++) {
			while (!bucketA.get(i).isEmpty()) {
				array[j++] = bucketA.get(i).remove();
			}
		}
	}
}

package org.vanjor.sort;

public interface Sorter {
	public String getName();
	public void sort(int[] array);
}

package org.vanjor.sort;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;

import org.junit.Assert;
import org.junit.Test;

public class SortTest {

	@Test
	public void testAll() {
		List<Sorter> list = new LinkedList<Sorter>();
		list.add(new BubbleSort());
		list.add(new HalfInsertSort());
		list.add(new HeapSort());
		list.add(new InsertSort());
		list.add(new MergeSort());
		list.add(new QuickSort());
		list.add(new RadixSort());
		list.add(new SelectSort());
		list.add(new ShellSort());

		int turns = 1000;
		for (int i = 0; i < turns; i++) {
             for(Sorter sorter:list){
            	 if(sorter.getName().equals("HeapSort")){
            		 testSorterForHeapSort(sorter,i);
            	 }else{
            		 testSorter(sorter,i);
            	 }
             }
		}
	}

	public void testSorter(Sorter sorter, int num) {
		int[] source = generateArray(num);
		int[] result = Arrays.copyOf(source, source.length);
		Arrays.sort(result);
		int[] compute = Arrays.copyOf(source, source.length);
		sorter.sort(compute);
		Assert.assertTrue(sorter.getName() + ":compute:"
				+ Arrays.toString(compute) + ":right:"
				+ Arrays.toString(result), Arrays.equals(compute, result));
	}

	public void testSorterForHeapSort(Sorter sorter, int num) {
		int [] original =generateArray(num);
		int[] source = getArrayForHeapSort(original);
		Arrays.sort(original);
		int[] result = getArrayForHeapSort(original);
		int[] compute = Arrays.copyOf(source, source.length);
		sorter.sort(compute);
		Assert.assertTrue(sorter.getName() + ":compute:"
				+ Arrays.toString(compute) + ":right:"
				+ Arrays.toString(result), Arrays.equals(compute, result));
	}

	public static int[] getArrayForHeapSort(int[] src) {
		if (src == null || src.length == 0) {
			return src;
		} else {
			int[] ge = new int[src.length + 1];
			ge[0] = 0;
			for (int i = 0; i < src.length; i++) {
				ge[i + 1] = src[i];
			}
			return ge;
		}
	}

	public static int[] generateArray(int lens) {
		Random rd = new Random(System.currentTimeMillis());
		int[] rs = new int[lens];
		for (int i = 0; i < lens; i++) {
			rs[i] = rd.nextInt(1001);
		}
		return rs;
	}

}

排序延伸思考

猜您也喜欢：
算法：已排序数组中找出现最多的数字	算法：科克曼女生问题的一种解法	算法：求字符串指定最小全集子串	算法：图论中Dijkstra最短路径搜寻算法
无觅

相关文章

• 算法：求字符串指定最小全集子串(0)
• 算法：已排序数组中找出现最多的数字(2)
• 算法：科克曼女生问题的一种解法(0)

最近评论

• vanjor : 补充一个：排序算法的声音效果：http://www.aqee.net/2010/09/22/the-...

给定一字符串str，以及一个char数组序列dic，要求找到str中包含有dic中所有不同的char的一个最小长度的子串（如果有多个，找出最左边的一个）

例如:str="ffaaeaaecfeaec", dic={‘a’,'c’,'f’}，则最小子串为aecf，这里满足包含dic所有序列的子串有："ffaaeaaec"，"faaeaaec"，"aaeaaecf"，"aecf"，"cfea"等，但是即是长度最短又是最左边的一个子串只有一个为“aecf”。

思路

本题为字符串中的一道算法题目，也是IT公司的一道笔试题，难点在于既不是直接的字符串查找，又需要字典标记，找到所有可能的解，并且从中找出最优解，简单的分治思路，线性规划都不适合。

一种最直接上层的思路，就是顺序扫描串中的字符，检查当前覆盖的一段中的达标子串，并比较长度只保留当前最后解，以后每次得到新的符合要求的，只与之前最优解比较，如更优则进行替换。最后串扫描完，即返回了整串的最优解，核心在从局部最优解最终扩展到全局最优解。

那么具体实施的话，用一个当前最优子串 len(长度)，start（offset），end（offset），在扫描过程中也会有一个当前扫描的可能的解loc_len,loc_start,loc_end，在扫描过程中找到一解后并比较，之后需要进一步前进，这个时候如果在动态中找到当前子串的模式，不用回溯，直接原地前进，就是十分关键的，这样的话程序时间效率就是O（n）了，n为串长度。

最优解答

通过两个游标，一前一后从字符串开头进行扫描，不断找到局部最优解，比较得到当前最优解，通过计数器，可以得到每次的局部最优解，同时两个游标一前一后卡位，避免了回溯。这里字典可以用数组更高效，但用HashMap可以将更精髓的展现出来。

评估：

记字符串str长度为n，char序列长度为m

• 时间复杂度：o(n)  ，更精确为2n
• 空间复杂度：o(m)

Code

package org.vanjor.str;

import java.util.HashMap;

public class BetterFindMost {

	public static String findSubString(char[] targetList, String targetStr) {

		// 异常情况直接返回
		if (targetList == null || targetStr == null || targetList.length == 0
				|| targetStr.length() == 0) {
			return null;
		}

		// 构造targetList字典表
		HashMap<character   , integer> mapDic = new HashMap<character   , integer>();

		for (char c : targetList) {
			mapDic.put(c, 0);
		}
		// 字典表也就是targetList的不同目标的累积长度的完成量
		int finished = 0;

		// 对应的起始位置
		int mostStart = 0;
		// 对应的终止位置
		int mostEnd = 0;

		// 正在进行的轮次子串起始位置
		int curStart = 0;
		// 正在进行的轮次子串终止位置
		int curEnd = 0;

		// 初始游标pos遍历targetStr
		for (int pos = 0; pos &lt; targetStr.length(); pos++) {

			// 当前游标所指字符
			char posChar = targetStr.charAt(pos);

			if (mapDic.get(posChar) == null) {
				continue;
			} else if (mapDic.get(posChar) == 0) {
				//登记起点
				if (finished == 0) {
					curStart = pos;
				}
				//计数
				mapDic.put(posChar, 1);
				//任务完成量+1
				finished++;
			} else {
				//对应计数+1
				mapDic.put(posChar, mapDic.get(posChar) + 1);
			}

			//检查字串头部游标是否可以向前进，在不降低任务完成量下，缩短长度
			char startChar = targetStr.charAt(curStart);
			while (mapDic.get(startChar) == null || mapDic.get(startChar) &gt; 1) {
				if (mapDic.get(startChar) != null) {
					mapDic.put(startChar, mapDic.get(startChar) - 1);
				}
				curStart++;
				startChar = targetStr.charAt(curStart);
			}

			//登记当前轮次解，比较得出当前最优解，同时头部迁移，已完成任务量-1，继续找下一个满足条件
			if (finished == mapDic.size()) {
				//登记结尾
				curEnd = pos + 1;
				System.out.println(targetStr.substring(curStart, curEnd));

				if (((mostEnd - mostStart) == 0)
						|| ((curEnd - curStart) &lt; (mostEnd - mostStart))) {
					mostStart = curStart;
					mostEnd = curEnd;
				}
				mapDic.put(targetStr.charAt(curStart), 0);
				curStart++;
				finished--;
			}

		}
		// 如果能找到，则返回结果
		if ((mostEnd - mostStart) != 0) {
			return targetStr.substring(mostStart, mostEnd);
		}
		return null;
	}
}

Test

package org.vanjor.str;

import junit.framework.Assert;

import org.junit.Test;

public class BetterFindMostTest {
	@Test
	public void testFindSubString0() {
		char[] array = new char[] {};
		String str = "aaacdac";
		Assert.assertEquals(FindMost.findSubString(array, str) == null, true);
	}

	@Test
	public void testFindSubString1() {
		char[] array = new char[] { 'a' };
		String str = "";
		Assert.assertEquals(BetterFindMost.findSubString(array, str) == null, true);
	}

	@Test
	public void testFindSubString2() {
		char[] array = new char[] { 'a' };
		String str = "cccaaacc";
		Assert.assertEquals(BetterFindMost.findSubString(array, str),BetterFindMost.findSubString(array, str).equals("a"),
				true);
	}

	@Test
	public void testFindSubString3() {
		char[] array = new char[] { 'f' };
		String str = "cccaaacc";
		Assert.assertEquals(BetterFindMost.findSubString(array, str) == null, true);
	}

	@Test
	public void testFindSubString4() {
		char[] array = new char[] { 'a', 'c' };
		String str = "cccaaacc";
		Assert.assertEquals(BetterFindMost.findSubString(array, str).equals("ca"),
				true);
	}

	@Test
	public void testFindSubString5() {
		char[] array = new char[] { 'a', 'c' };
		String str = "ffaecfecfaec";
		Assert.assertEquals(BetterFindMost.findSubString(array, str), BetterFindMost
				.findSubString(array, str).equals("aec"), true);
	}

	@Test
	public void testFindSubString6() {
		char[] array = new char[] { 'a', 'c' ,'f'};
		String str = "ffaaeaaecfeaec";
		Assert.assertEquals(BetterFindMost.findSubString(array, str), BetterFindMost
				.findSubString(array, str).equals("aecf"), true);
	}

	@Test
	public void testFindSubString7() {
		char[] array = new char[] { 'a', 'c' ,'k'};
		String str = "ffaeecfeacfaec";
		Assert.assertEquals(BetterFindMost.findSubString(array, str), BetterFindMost
				.findSubString(array, str)==null, true);
	}

	@Test
	public void testFindSubString8() {
		char[] array = new char[] { 'a', 'c' };
		String str = "ffaeacfecfaec";
		Assert.assertEquals(BetterFindMost.findSubString(array, str), BetterFindMost
				.findSubString(array, str).equals("ac"), true);
	}

	@Test
	public void testFindSubString9() {
		char[] array = new char[] { 'a', 'c' ,'f'};
		String str = "ffaeaaecfaeaec";
		Assert.assertEquals(BetterFindMost.findSubString(array, str), BetterFindMost
				.findSubString(array, str).equals("cfa"), true);
	}

	@Test
	public void testFindSubString10() {
		char[] array = new char[] { 'a', 'c' ,'f'};
		String str = "caf";
		Assert.assertEquals(BetterFindMost.findSubString(array, str), BetterFindMost
				.findSubString(array, str).equals("caf"), true);
	}

	@Test
	public void testFindSubString11() {
		char[] array = new char[] { 'a', 'b'};
		String str = "ba";
		Assert.assertEquals(BetterFindMost.findSubString(array, str), BetterFindMost
				.findSubString(array, str).equals("ba"), true);
	}

	@Test
	public void testFindSubString12() {
		char[] array = new char[] { 'a'};
		String str = "a";
		Assert.assertEquals(BetterFindMost.findSubString(array, str), BetterFindMost
				.findSubString(array, str).equals("a"), true);
	}
}

之前的一个解答

下面为自己之前所写出的一个解答方法，这个答案虽然通过全部测试用例，但是内部多大十几个变量相互关联变化，是debug了3,4小时才得到完全正确的结果，思路蕴含了为在游标前进的时候为母串建模，子串在游标前进动态在母串模型中跳跃前进，前面的最优解实际上由本解答得到启发，更加灵活的运用计数器这个奇淫技巧，在这里仍然贴出来，见证算法的确很神奇，越深入越能简洁的优雅的解决问题。

Java语言实现，其中字典Map可以用数组实现，标记序列可以用int[]数据来实现，因为不为关键环节，此处采用HashMap，和ArrayList，简化处理：

评估：

记字符串str长度为n，char序列长度为m

• 时间复杂度：o(n)
• 空间复杂度：o(n)+o(m)

Code

package org.vanjor.str;

import java.util.ArrayList;
import java.util.HashMap;

public class FindMost {

	public static String findSubString(char[] targetList, String targetStr) {

		//异常情况直接返回
		if (targetList == null || targetStr == null || targetList.length == 0
				|| targetStr.length() == 0) {
			return null;
		}

		//构造targetList字典表
		HashMap<Character, Integer> mapDic = new HashMap<Character, Integer>();
		//构造匹配字典表对应的targetStr的位置序列
		ArrayList<Integer> breakPoint = new ArrayList<Integer>();
		//初始化字典表，对应初始标记为false
		for (char c : targetList) {
			mapDic.put(c, 0);
		}
		//字典表也就是targetList的不同目标的累积长度，
		int matchCount = mapDic.size();

		//当前最优解的子串长度
		int mostLen = 0;
		//对应的起始位置
		int mostStart = 0;
		//对应的终止位置
		int mostEnd = 0;

		//正在进行的轮次子串长度
		int curLen = 0;
		//正在进行的轮次子串起始位置
		int curStart = 0;
		//正在进行的轮次子串终止位置
		int curEnd = 0;

		//正在进行的轮次对应首词在targetStr中的位置，并保存在breakPoint.get(turn)中
		int turn = 0;

		//初始游标pos遍历targetStr
		for (int pos = 0; pos < targetStr.length(); pos++) {
			//当前游标所指字符
			char posChar = targetStr.charAt(pos);

			//如果上个字符到本次字符发生变化，而且上个字符是字典中的字符，
			//那么将上个字符在整个字符串targetStr种的偏移添加到breakPoint序列中，
			//实际上breakPoint序列存放关键节点
			if (pos != 0 && posChar != targetStr.charAt(pos - 1)
					&& mapDic.get(targetStr.charAt(pos - 1)) != null) {
				breakPoint.add(pos - 1);// 有效转折点
			}

			//如果当前字符不在字典中
			if (mapDic.get(posChar) == null) {
				//如果当前轮次为吞进任何有效字符，则游标直接前进，下一次处理
				//若处于已吞进有效字符状态，当前字串长度需要加1，进入下一次处理
				if (matchCount != mapDic.size()) {
					curLen++;
				}
				continue;
			} else {
				//如果当前轮次序列不包含该字符
				if (mapDic.get(posChar)==0) {
					//如果当前轮次字串为吞进任何有效字符，则初始化对应的start位置
					if (matchCount == mapDic.size()) {
						curStart = pos;
					}
					//置字典对应为true，表明现在当前字串中包含当前的posChar
					mapDic.put(posChar, 1);
					//当前任务量减1
					matchCount--;
					//当前子字符串长度+1
					curLen++;
				} else {
					if (matchCount == mapDic.size() - 1) {
						//如果子串只完成一个独自字典字符，并且当前的这个依然是那个独立字符，则
						//直接调整子串头部移到当前位置
						curStart = pos;
						curLen = 1;
					} else {
						//如果子串末尾的字符与开始的字符是同一字典字符，则调整字串的开始字符
						//移到下一个字串中独立字符来
						if (targetStr.charAt(curStart) == posChar
								&& pos != curStart) {
							//当前字串关键节点+1，breakPoint.get(turn)即为当前子串第二个独立字典字符
							//的最优位置，并更新长度，减掉头部所见的长度
							turn++;
							curStart = breakPoint.get(turn);
							curLen = curLen - (breakPoint.get(turn) - curStart);

						}else if(posChar!=targetStr.charAt(pos - 1)){
							//如果为转折关键点，并在词典中，同时子串中已存在，对其字典计数+1
							mapDic.put(posChar, mapDic.get(posChar)+1);
						}
						//当前字符被吃进，总长度+1
						curLen++;
					}
				}
			}
			//当前轮次后，如果总任务量刚好完成
			if (matchCount == 0) {
				//标记当前轮次字串的终止位置
				curEnd = pos;
				//比较当前子串与历史最佳字串，如果当前子串更短，则直接覆盖历史最佳字串信息
				if (curLen < mostLen || mostLen == 0) {
					mostLen = curLen;
					mostStart = curStart;
					mostEnd = curEnd;
				}
				//最优解直接退出循环，如果当前轮次后，字串的长度恰好为原始序列，字典表长度，
				//再也不能找到比这更短的，也就是当前就是最优解，直接停止继续查找
				if (mostLen == mapDic.size()) {
					break;
				}

				//开始顺移当前子串，舍弃头结点字符，尝试查下一个优解
				//置要舍弃的头结点字符字典表为为完成访问状态
				mapDic.put(targetStr.charAt(curStart), 0);
				if (mapDic.size() == 2) {
					//如果字典表任务本身长度为2，直接当前字串以当前pos位置开始
					curLen = 1;
					curStart = pos;
				} else {
					//如果大于2的话，在序列中查找对于第二独立字符在targetStr中的位置，并顺移动
					turn++;
					curLen = curLen - (breakPoint.get(turn) - curStart);
					curStart = breakPoint.get(turn);

					//当蛇头有冗余，缩到关键节点处打住
					while(mapDic.get(targetStr.charAt(curStart))>1){
						mapDic.put(targetStr.charAt(curStart), mapDic.get(targetStr.charAt(curStart))-1);
						turn++;
						curLen = curLen - (breakPoint.get(turn) - curStart);
						curStart = breakPoint.get(turn);
					}
				}
				//舍弃子串头部已满足那个任务，遗留任务+1
				matchCount++;
			}
		}
		//如果能找到，则返回结果
		if (mostLen != 0) {
			return targetStr.substring(mostStart, mostEnd + 1);
		}
		return null;
	}
}

猜您也喜欢：
排序算法大合集与思考	算法：已排序数组中找出现最多的数字	算法：科克曼女生问题的一种解法	算法：图论中Dijkstra最短路径搜寻算法
无觅

相关文章

• 排序算法大合集与思考(1)
• 算法：已排序数组中找出现最多的数字(2)
• 算法：科克曼女生问题的一种解法(0)

最近评论

边整理边写了整整一天o(╯□╰)o

一、背景

二、分类概述

三、协同过滤三大分类

四、相似度计算算法

五、协同过滤敏捷实践

六、算法评价指标

一些参考：

• http://zh.wikipedia.org/zh-cn/%E5%8D%94%E5%90%8C%E9%81%8E%E6%BF%BE
• http://www.cs.carleton.edu/cs_comps/0607/recommend/recommender/
• http://www.cs.carleton.edu/cs_comps/0607/recommend/recommender/svd.html
• http://wenku.baidu.com/view/e12b10ea81c758f5f61f67fb.html
• http://zh.wikipedia.org/wiki/Slope_one
• http://www.kuqin.com/algorithm/20080903/16387.html
• http://www.cnblogs.com/kuber/archive/2008/06/10/1216846.html
• 更多参照文章中的链接

相关文章

• Java统计报表与绘图(0)

最近评论

• wiizane : 总结的不错。

最短路径问题

Dijkstra算法

package org.vanjor.map;

import java.util.ArrayList;
import java.util.LinkedList;

/**
 * Dijkstra最短路径搜寻算法Java实现
 * @author Vanjor
 */
public class DijkstraMap {

	/**
	 * 实现Dijkstra最短路径搜寻算法
	 * @param map
	 *        输入，为图矩阵，可以有向或无向图，距离为-1表示无穷远，一非负值表示一个实际距离
	 *        map[i][i]自身距离初始化为0，
	 *        起始节点从0开始
	 * @param start
	 *        出发节点
	 * @param end
	 *        目标节点
	 * @return
	 *        LinkedList<Integer> ，第一位表示总里程，-1表示无穷远，随后表示从start到end的路径节点
	 */
	public static LinkedList<Integer> getShortest(int[][] map, int start,
			int end) {

		int len = map.length;

		// 对应pathMileage[i]为当前start到i的最短距离
		int[] pathMileage = new int[len];
		boolean[] isDefined = new boolean[len];
		ArrayList<ArrayList<Integer>> pathWay = new ArrayList<ArrayList<Integer>>();

		// 初始化里程计数与是否确定为最短里程的标记量
		for (int cursor = 0; cursor < len; cursor++) {
			pathMileage[cursor] = map[start][cursor];
			pathWay.add(new ArrayList<Integer>());
			if (pathMileage[cursor] >= 0) {
				pathWay.get(cursor).add(start);
				pathWay.get(cursor).add(cursor);
			}
			isDefined[cursor] = false;
		}

		// 初始化对应 start->start的里程距离为0，并且确定为start->start最短里程
		pathMileage[start] = 0;
		isDefined[start] = true;

		// 将len长度的点，分类两组，一组是确定好了start到该点最短距离的点集，
		// 对应isDefined标记为true， 另一组为尚未确定，对应isDefined标记为true
		// 其中addUpCount为对以确定好最短距离点集的计数

		int addUpCount = 1;

		// 当节点全部确定最短距离后，即退出循环检查
		while (addUpCount < len) {
			// 每一轮次，待确定最短距离集中的最小值
			int turnMinMileage = -1;
			// 对应最小值的pathMileage行值
			int turnMinPoint = -1;

			for (int cusor = 0; cusor < len; cusor++) {
				// 如果对应的节点cusor已经确定最短距离则不参与排序搜寻
				if (isDefined[cusor]) {
					continue;
				}
				// 在当前未确定最短距离的节点集中找出最短距离turnMinMileage
				// 以及对应节点isDefined
				if (turnMinMileage == -1 && pathMileage[cusor] >=0) {
					// 对遇到第一个不是无穷远的距离点，将对应的值覆盖初始化点
					turnMinMileage = pathMileage[cusor];
					turnMinPoint = cusor;
				} else if (turnMinMileage >= 0 && pathMileage[cusor] >=0
						&& pathMileage[cusor] < turnMinMileage) {
					// 找到更小的点，进行覆盖
					turnMinMileage = pathMileage[cusor];
					turnMinPoint = cusor;
				}
			}

			// 如果当前轮次，再也找不到距离非无穷远的未确定远点，
			// 则证明剩下的点为非连通点，也可同样退出while循环检查
			if (turnMinMileage == -1) {
				break;
			}

			// 为当前所找到的最短距离点标记为已确定
			isDefined[turnMinPoint] = true;
			// 已确定点+1计数
			addUpCount++;

			// 遍历查看，对于新加点turnKeyPoint，
			// 有没有可能改进原始的start到各点的最短距离
			for (int cursor = 0; cursor < len; cursor++) {
				// 已确定的就不在考虑中
				if (isDefined[cursor]) {
					continue;
				}
				// 当pathMileage以登记的start->turnKeyPoint以及
				// turnKeyPoint—>cursor的距离都非无限远，则可以考虑比较
				if (pathMileage[turnMinPoint] != -1
						&& map[turnMinPoint][cursor] != -1) {
					// 待考虑的新加节点turnKeyPoint组成的路径start->..->turnKeyPoint->cursor；
					int newLen = pathMileage[turnMinPoint]
							+ map[turnMinPoint][cursor];
					// 作比较，若小则覆盖,或者原来距离为无穷远也覆盖
					if (newLen < pathMileage[cursor]
							|| pathMileage[cursor] == -1) {
						pathMileage[cursor] = newLen;
						copyPathWay(pathWay.get(turnMinPoint), pathWay
								.get(cursor), cursor);
					}
				}
			}
		}
		LinkedList<Integer> rs = new LinkedList<Integer>();
		rs.addAll(pathWay.get(end));
		rs.add(0, pathMileage[end]);
		return rs;
	}

	private static void copyPathWay(ArrayList<Integer> source,
			ArrayList<Integer> destiny, int addPoint) {
		while (!destiny.isEmpty()) {
			destiny.remove(0);
		}
		destiny.addAll(source);
		destiny.add(addPoint);
	}

	//初始化图
	public static int[][] generateMap() {
		int[][] map = new int[6][6];
		map[0][5] = 100;
		map[0][4] = 30;
		map[0][2] = 10;
		map[1][2] = 5;
		map[2][3] = 50;
		map[3][5] = 10;
		map[4][5] = 60;
		map[4][3] = 20;
		int len = map.length;
		for (int i = 0; i < len; i++) {
			for (int j = 0; j < len; j++) {
				if (i == j) {
					map[i][j] = 0;
				} else if (map[i][j] == 0) {
					map[i][j] = -1;
				}
			}
		}
		return map;
	}

	public static void main(String[] args) {
		System.out.println(getShortest(generateMap(), 0, 5));
	}
}

参考：

• http://www.nocow.cn/index.php/Dijkstra%E7%AE%97%E6%B3%95
• http://baike.baidu.com/view/7839.htm
• http://2728green-rock.blog.163.com/blog/static/43636790200901211848284/
• http://books.google.com.hk/books?id=6xWGGb4z2LgC&printsec=frontcover&hl=zh-CN

相关文章

• 0

最近评论

• 其一：知乎上某人写面试豆瓣产品经理的经历，被N顿逼问成功还是失败，过程很欢乐，详情：http://www.douban.com/note/146145117/，下面给出一个片段：

大眼哥哥：那么一个成功的产品的标准又是什么？

我道：理想的情况是，既让用户满意，得到了用户的美誉，又完成了领导的战略，达到了比如说赚钱这种目标，这就是一个很不错的产品。

大眼哥哥：不错是什么，如果必须界定成功或失败呢？

我道：那么就说是一个成功的产品吧。

大眼哥哥：哦，这样就是成功的，那按照你这么说，腾讯的QQ秀之类的，都是成功的产品咯？

我道：嗯，虽然是运营为主的一个产品，但是也不算失败吧。

大眼哥哥：什么叫不算失败，是成功还是失败，我需要知道你的标准！

我内心独白：汗……

我道：非要这么界定的话，那就算是成功的产品吧。

大眼哥哥：那么按照你的标准，随便来一个人，只要他做得产品是符合领导需求的，用户也很喜欢，那就是成功的产品经理咯？那么是不是说一个SP的彩信做得很赚钱，也是一个成功的产品经理？

我道：这种情况，要看一个前提，看是否运营层面占主流，比如类似新浪微博这样的产品，可能产品上并没有多大的创新，但是运营的好，所以产品水平一般，但是也很受欢迎。

(此时，我似乎看到了大眼哥哥眼中金光一闪，犹如老鹰看到了脱兔的眼神！）

大眼哥哥：所以，你觉得新浪微博是一个成功还是失败的产品？

• 其二：校内上一同学的状态：很早就听过一个说法，大部分人的苦恼来自“他既想活得成功，又想活得有意义”。我还是不知道自己究竟想要哪种人生。

倘若有一天，有人问我，我活到现在自我感觉活的成功么，有意义么？我自己都怕不知怎么去回答，似乎我们天天挂在嘴头或心头，某某做的比较成功，最近做的很没意义，究竟什么是算为成功，什么才是有意义呢？我们心里的那件标杆又是什么呢？

从权威百科参考：

• 成功，即获得预期的结果，异或逐步实现有价值的理想。
• 意义，一个人或事给人的主客观判断，又做作用，价值。

对于其一：

参照百科释义，成功的标准其实是很简单，也就是做一件事情，并且达到预期的目的。很明显，其实这个最原始的成功并无任何褒贬之意（比如特工成功的完成了该次刺杀行动），而且只有执行人才能最好的判定成功与否，因为执行人才是在执行前设定目标的。如果让旁人评测的话，那么旁人只能是选取一些相对坐标，评估当事人的目标，依照所选取的参照系评估当事人的完成的情况，这样判定起来也就简单了，也就不会总是让是否有意义什么的混杂在其中。

如果下次要是对方问我一个成功的产品的标准又是什么？我会首先回答，成功的标准就是达到产品实现设定的预期的结果。哈哈。

对于其二：

实质上也是要找到成功与意义的本质与衡量标准，从文中推断，这个成功是活在他人眼中的成功，这个意义是活在自己心中有意义，其实更多的时候这两者处在完全不同的参照系中，而又大家基本具有普世的自然观与价值观，两者又并不矛盾。

从权威百科参考：实际上成功就是追求一个有意义的结果。也就是实际上成功与意义内涵是一致性的内核都是在于价值的判断，成功与意义均是表象，透过现象看本质，实质上是表里如一的，价值的统一体，最原始的成功与意义定义与判定都应当是从自身角度（价值观）去判定权衡。

但是大众在做成功与意义的判断时，往往没有严格遵守完全从自身角度（排他性的）观察判定的标准，大众的认识角度成功是外显的（外部显露，他人的看法），意思是内省的（自我认识与价值判定），而每个人的价值观世界观并非一致，决定了自我的价值观与他们的价值观的矛盾差异性，也就让大众所认识的成功与自我认定的意义看起来是时常矛盾的。

因而在一件件事情前，当自我的价值观与他人或大众价值观不一致的情况下，个人必须做出抉择，是妥协与他人还是坚持自己。这也就是为什么小时候教育就开始培养大家树立正确的价值观与社会观，因为那些如果价值观社会观完全与普世的偏差太大或对立下，那个自我的坚持必然导致一种与社会的格格不入，更严重得则是走向一种自我毁灭。

而实际上最后问题等同于是选择活在自己心中还是活在他人眼里，假定普世的世界观和价值观是完美的，并且大众都达到这一水平，那么这个矛盾实际上就是个人的价值观并没有达到普世的价值观一个高度与完美上，而事实上，当前并没有一个普世的世界观与价值观，每个人所参考的外显成功定义都是选取一个子集合作为坐标参照系与自身的内显意义做比较而得出的矛盾，因而综上所述，最后问题的答案也在于此：你是想活在自己的心中，还是活在“我”的心中。

最后附一个白岩松的语句，一家之言，仁者见仁智者见智：

我们支援朝鲜石油、粮食，却发现那是个无底洞；支援外蒙建设，他们却把中国工人关进监狱；支持非洲建厂，他们却责怪中国设备落后。这些受援国对中国并无好感，中国的牺牲和奉献得不到友谊，难道中国人是天下最大傻瓜？中国与世界脱节最大是普世价值，与他国没有共同的价值观，所以得不到朋友。

相关文章

• 0

最近评论

• vanjor : 额，暴露了~想着想着觉得还是单独写出来，恩，要是能出去读书就更好了，北京人口大约是武汉人口的2倍，志...
• lilyy : 呵呵，看来大家都对这个问题比较困惑~~要是我不能出去念书，我也想来北京，在这里应该能找到更多志同道合...

题目如下：

给定一个数组，内容是已经排序好的整数，并且确定有一个数的出现次数大于数组长度的一半，试着最快找出那个数。

如{ 1, 1, 4, 6, 6, 6, 6, 6, 6, 7 } 对应所找的数为6

方案一：对于数字序列问题，很多都是最后归结与查找，排序的核心问题，此题最明显的一个想法是遍历数组，并且对与每个不同的数字进行计数，用Set或者hash的array来统计，此处不列出该方法解答。

方案二：注意到是已经排序好的数组，那么每个相同的数也都是连续的，包括待求数，顺序遍历数组，设立一个标记量A记录当前出现次数最多的数，初始置零，一个标记量B记录出现该数的出现次数统计值，初始置零，游标从第一个数开始，不断统计，若出现新的记录，则放到标记量A，B中，最后返回的A，即为所求之数即为数组中出现次数最多那个数：

算法如下：

	public static int getMostPoint1(int[] array) {
		//当前序列标记值，与次数值
		int mostNumber = 0, mostNumberCount = 0;
		//游标临时数，与次数统计值
		int cusorNumber = array[0], cusorNumberCount = 0;
		for (int index = 0; index < array.length; index++) {
			if (cusorNumber == array[index]) {
				cusorNumberCount++;
			} else {
				if (cusorNumberCount > mostNumberCount) {
					mostNumber = cusorNumber;
					mostNumberCount = cusorNumberCount;
				}
                                //重置游标临时值
				cusorNumber = array[index];
				cusorNumberCount = 1;
			}
		}
		return mostNumber;
	}

方案三：注意到题目中，所出现次数大于长度的一半，那么，实际上方案二中，若游标数统计值没有到长度的一般，就可立刻抛弃，不需要标记量记录，也就是找到就返回，没有找到继续找。基于方案二的算法可以更简洁化：

算法如下：

	public static int getMostPoint2(int[] array) {
		int cusorNumber = array[0], cusorNumberCount = 0;
		//若次数大于长度一半，立刻退出循环，并返回该数
		for (int index = 0; index < array.length
				&& cusorNumberCount <= array.length / 2; index++) {
			if (cusorNumber == array[index]) {
				cusorNumberCount++;
			} else {
				cusorNumber = array[index];
				cusorNumberCount = 1;
			}
		}
		return cusorNumber;
	}

方案四：注意到某个数次数大于数组长度的一半，那么假设长度100的Array[100]，判断A[0]是否为所求数，实际上看A[0]==A[50]成立与否就行，那么A[1]呢..那么A[99]呢？那么仔细想想，其实这道题目的答案很happy的只用一行计算语句:

算法如下：

	public static int getMostPoint3(int[] array) {
		return array[array.length / 2];
	}

相关文章

• 排序算法大合集与思考(1)
• 算法：求字符串指定最小全集子串(0)
• 算法：科克曼女生问题的一种解法(0)

最近评论

• tian : o ,是不确定有这个过半的数的时候
• tian : 这个题似乎有O(logn)的解法