<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[A2BGeek的专栏]]></title><description><![CDATA[强大源于自律]]></description><link>https://blog.youkuaiyun.com/benbmw2008</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; benbmw2008]]></copyright><item><title><![CDATA[【数据结构与算法】重建二叉树]]></title><link>https://blog.youkuaiyun.com/benbmw2008/article/details/39078745</link><guid>https://blog.youkuaiyun.com/benbmw2008/article/details/39078745</guid><author>benbmw2008</author><pubDate>Fri, 05 Sep 2014 11:35:39 +0800</pubDate><description><![CDATA[只能根据前序中序或者中序后序重建二叉树，不可能根据前序和后序重建，因为需要中序去划分左右子树。

代码实现
/**
 * 源码名称：ConstructBT.java 
 * 日期：2014-09-05
 * 程序功能：重建二叉树（前序中序）
 * 版权：CopyRight@A2BGeek 
 * 作者：A2BGeek
 */
public class ConstructBT {
	class]]></description><category></category></item><item><title><![CDATA[【数据结构与算法】java链表操作]]></title><link>https://blog.youkuaiyun.com/benbmw2008/article/details/39076983</link><guid>https://blog.youkuaiyun.com/benbmw2008/article/details/39076983</guid><author>benbmw2008</author><pubDate>Fri, 05 Sep 2014 09:53:07 +0800</pubDate><description><![CDATA[链表操作代码量少但是比较容易出错，是比较适合面试的地方。

代码实现
/**
 * 源码名称：MyLinkList.java 
 * 日期：2014-09-05
 * 程序功能：java链表操作 
 * 版权：CopyRight@A2BGeek 
 * 作者：A2BGeek
 */
import java.util.Stack;

public class MyLinkList {
	cla]]></description><category></category></item><item><title><![CDATA[【数据结构与算法】字符串匹配KMP算法]]></title><link>https://blog.youkuaiyun.com/benbmw2008/article/details/39022705</link><guid>https://blog.youkuaiyun.com/benbmw2008/article/details/39022705</guid><author>benbmw2008</author><pubDate>Wed, 03 Sep 2014 10:19:48 +0800</pubDate><description><![CDATA[首先需要了解一下BF暴力匹配算法，这个算法为每一个串设置一个指针，然后两个指针同时后移，出现不匹配的情况后，主串指针回到开始后移之前的位置的下一位，模式串指针回到最开始。
对比一下KMP算法，同样是设置两个指针，然后两个指针同时后移，出现不匹配的情况后，主串指针不变，模式串指针回溯一定的距离。具体模式串指针回溯多少，是第一次看KMP算法的人比较难以理解的，其实仔细想想，模式串的前缀和后缀其实也是]]></description><category></category></item><item><title><![CDATA[【数据结构与算法】LCS（连续）]]></title><link>https://blog.youkuaiyun.com/benbmw2008/article/details/39008717</link><guid>https://blog.youkuaiyun.com/benbmw2008/article/details/39008717</guid><author>benbmw2008</author><pubDate>Wed, 03 Sep 2014 08:55:58 +0800</pubDate><description><![CDATA[今年阿里的笔试题，就有一道是求连续的公共子串。
思路一：我当时第一反应是把其中较短的一个串的所有子串的都求出来，然后用这些子串（先用长度较长的）去长串里面做匹配。后来一想效率太低了。
思路二：效仿不连续的LCS问题，先把表填了，然后再在表里面找。

代码实现
/**
 * 源码名称：LCString.java 
 * 日期：2014-09-02 
 * 程序功能：LCS（连续） 
 * ]]></description><category></category></item><item><title><![CDATA[【数据结构与算法】LCS（不连续）]]></title><link>https://blog.youkuaiyun.com/benbmw2008/article/details/39008573</link><guid>https://blog.youkuaiyun.com/benbmw2008/article/details/39008573</guid><author>benbmw2008</author><pubDate>Tue, 02 Sep 2014 17:02:36 +0800</pubDate><description><![CDATA[这个问题很经典，典型的动态规划，动态规划就是填一个表，然后遍历一下就行了。

代码实现
/**
 * 源码名称：LCSequence.java 
 * 日期：2014-09-02 
 * 程序功能：LCS（不连续） 
 * 版权：CopyRight@A2BGeek 
 * 作者：A2BGeek
 */
public class LCSequence {
	private String mOn]]></description><category></category></item><item><title><![CDATA[【数据结构与算法】图的深度与广度遍历]]></title><link>https://blog.youkuaiyun.com/benbmw2008/article/details/38823351</link><guid>https://blog.youkuaiyun.com/benbmw2008/article/details/38823351</guid><author>benbmw2008</author><pubDate>Mon, 25 Aug 2014 17:15:50 +0800</pubDate><description><![CDATA[图的深度遍历与广度遍历与二叉树的遍历类似，但是因为是图，需要有个数组存一下点是否被遍历过。

代码实现
/**
 * 源码名称：GraphIterateMatrix.java 
 * 日期：2014-08-25 
 * 程序功能：图的深度与广度遍历
 * 版权：CopyRight@A2BGeek 
 * 作者：A2BGeek
 */
import java.util.LinkedList;
]]></description><category></category></item><item><title><![CDATA[【数据结构与算法】二叉树广度遍历]]></title><link>https://blog.youkuaiyun.com/benbmw2008/article/details/38816775</link><guid>https://blog.youkuaiyun.com/benbmw2008/article/details/38816775</guid><author>benbmw2008</author><pubDate>Mon, 25 Aug 2014 11:11:44 +0800</pubDate><description><![CDATA[二叉树的广度遍历想想还是比较简单的，利用队列存储当前结点的左儿子和右儿子用作未来的访问。

代码实现
/**
 * 源码名称：TreeBFS.java 
 * 日期：2014-08-25 
 * 程序功能：二叉树广度遍历 
 * 版权：CopyRight@A2BGeek 
 * 作者：A2BGeek
 */
import java.util.LinkedList;
import java.u]]></description><category></category></item><item><title><![CDATA[【数据结构与算法】二叉树深度遍历（非递归）]]></title><link>https://blog.youkuaiyun.com/benbmw2008/article/details/38783685</link><guid>https://blog.youkuaiyun.com/benbmw2008/article/details/38783685</guid><author>benbmw2008</author><pubDate>Sat, 23 Aug 2014 22:55:42 +0800</pubDate><description><![CDATA[据说这个笔试面试的时候很容易考到，所以写到这里。

图示



代码实现
/**
 * 源码名称：TreeIteratorNoRecursion.java 
 * 日期：2014-08-23 
 * 程序功能：二叉树深度遍历（非递归） 
 * 版权：CopyRight@A2BGeek 
 * 作者：A2BGeek
 */
import java.util.Stack;

public]]></description><category></category></item><item><title><![CDATA[【数据结构与算法】二叉树深度遍历（递归）]]></title><link>https://blog.youkuaiyun.com/benbmw2008/article/details/38779067</link><guid>https://blog.youkuaiyun.com/benbmw2008/article/details/38779067</guid><author>benbmw2008</author><pubDate>Sat, 23 Aug 2014 16:06:03 +0800</pubDate><description><![CDATA[二叉树的深度遍历用递归的话就没有什么好说的了。

代码实现
/**
 * 源码名称：TreeIteratorRecursion.java 
 * 日期：2014-08-23 
 * 程序功能：二叉树深度遍历 
 * 版权：CopyRight@A2BGeek 
 * 作者：A2BGeek
 */
public class TreeIteratorRecursion {
	class TreeN]]></description><category></category></item><item><title><![CDATA[【数据结构与算法】二分查找]]></title><link>https://blog.youkuaiyun.com/benbmw2008/article/details/38555033</link><guid>https://blog.youkuaiyun.com/benbmw2008/article/details/38555033</guid><author>benbmw2008</author><pubDate>Thu, 14 Aug 2014 10:51:11 +0800</pubDate><description><![CDATA[基本思想
首先将给定的值K与表中中间位置元素比较，若相等，则查找成功；若不等，则所需查找的元素只能在中间数据以外的前半部分或者后半部分，缩小范围后继续进行同样的查找，如此反复，直到找到为止。

代码实现
/**
 * 源码名称：BinarySearch.java 
 * 日期：2014-08-14 
 * 程序功能：二分查找 
 * 版权：CopyRight@A2BGeek
 * 作者：A]]></description><category></category></item><item><title><![CDATA[【数据结构与算法】顺序查找]]></title><link>https://blog.youkuaiyun.com/benbmw2008/article/details/38538779</link><guid>https://blog.youkuaiyun.com/benbmw2008/article/details/38538779</guid><author>benbmw2008</author><pubDate>Wed, 13 Aug 2014 16:37:34 +0800</pubDate><description><![CDATA[基本思想
顺序查找是最简单的查找方法，从线性表的一端开始，依次将每个记录的关键字与给定值进行比较。

代码实现
/**
 * 源码名称：SeqSearch.java 
 * 日期：2014-08-13
 * 程序功能：顺序查找 
 * 版权：CopyRight@A2BGeek 
 * 作者：A2BGeek
 */
public class SeqSearch {
	public stati]]></description><category></category></item><item><title><![CDATA[【数据结构与算法】二路归并排序]]></title><link>https://blog.youkuaiyun.com/benbmw2008/article/details/38495345</link><guid>https://blog.youkuaiyun.com/benbmw2008/article/details/38495345</guid><author>benbmw2008</author><pubDate>Mon, 11 Aug 2014 17:00:39 +0800</pubDate><description><![CDATA[二路归并排序的时间复杂度是O(n*log2n)，空间复杂度是O(n)。
代码如下：
/**
 * 源码名称：MergeSort.java 
 * 日期：2014-08-11 
 * 程序功能：合并排序 
 * 版权：CopyRight@A2BGeek 
 * 作者：A2BGeek
 */
public class MergeSort {
	public void mergeSort(int[]]]></description><category></category></item><item><title><![CDATA[【数据结构与算法】希尔排序]]></title><link>https://blog.youkuaiyun.com/benbmw2008/article/details/38490031</link><guid>https://blog.youkuaiyun.com/benbmw2008/article/details/38490031</guid><author>benbmw2008</author><pubDate>Mon, 11 Aug 2014 11:29:06 +0800</pubDate><description><![CDATA[希尔排序的时间复杂度是O(n^1.3)~O(n^2)，空间复杂度是O(1)。
代码如下：
/**
 * 源码名称: ShellSort.java 
 * 日期：2014-08-11 
 * 程序功能：希尔排序 
 * 版权：CopyRight@A2BGeek 
 * 作者:A2BGeek
 */
public class ShellSort {
	public void shellSort(i]]></description><category></category></item><item><title><![CDATA[【数据结构与算法】直接插入排序]]></title><link>https://blog.youkuaiyun.com/benbmw2008/article/details/38488749</link><guid>https://blog.youkuaiyun.com/benbmw2008/article/details/38488749</guid><author>benbmw2008</author><pubDate>Mon, 11 Aug 2014 10:53:55 +0800</pubDate><description><![CDATA[直接插入排序的时间复杂度的O(N^2)，空间复杂度是O(1)。
下面是代码：
public class InsertionSort {
	public void insertionSort(int[] in) {
		int length = in.length;
		int i, j;
		for (i = 1; i < length; i++) {
			int tmp = in[i];]]></description><category></category></item><item><title><![CDATA[【数据结构与算法】堆排序]]></title><link>https://blog.youkuaiyun.com/benbmw2008/article/details/38440143</link><guid>https://blog.youkuaiyun.com/benbmw2008/article/details/38440143</guid><author>benbmw2008</author><pubDate>Fri, 08 Aug 2014 15:31:01 +0800</pubDate><description><![CDATA[堆排序的时间复杂度是O(nlogn)，下面上代码
public class HeapSort {

	public void adjustHeap(int[] in, int index, int length) {
		int leftcIndex = index * 2 + 1;
		int rightcIndex = index * 2 + 2;
		int bigest = index;]]></description><category></category></item><item><title><![CDATA[【leetcode系列】Valid Parentheses]]></title><link>https://blog.youkuaiyun.com/benbmw2008/article/details/38422333</link><guid>https://blog.youkuaiyun.com/benbmw2008/article/details/38422333</guid><author>benbmw2008</author><pubDate>Thu, 07 Aug 2014 17:30:26 +0800</pubDate><description><![CDATA[很经典的问题，使用栈来解决，我这里自己实现了一个栈，当然也可以直接用java自带的Stack类。
自己实现的栈代码：
import java.util.LinkedList;

class StackOne {
	LinkedList data;
	int top;
	int maxSize;

	StackOne(int size) {
		// TODO Auto-generated co]]></description><category></category></item><item><title><![CDATA[【leetcode系列】3Sum]]></title><link>https://blog.youkuaiyun.com/benbmw2008/article/details/38414175</link><guid>https://blog.youkuaiyun.com/benbmw2008/article/details/38414175</guid><author>benbmw2008</author><pubDate>Thu, 07 Aug 2014 10:34:13 +0800</pubDate><description><![CDATA[这个题我最开始的思路是：先一个数定下来，然后在除这个数之外的集合里面找另外两个数，最后计算和。如此反复，对于N个数，需要进行N-2次循环。
我遇到的问题就是怎么找另外两个数，其实我想过参照Two Sum里面的解法，就是用Hashtable存，键值对的结构是>，但是构造这个Hashtable就需要O(N^2)，后面真正解的时候有需要O(N^2)。
参考了大牛的解法后，明白了找两个数还是用两个下标]]></description><category></category></item><item><title><![CDATA[【数据结构与算法】选择排序]]></title><link>https://blog.youkuaiyun.com/benbmw2008/article/details/38407059</link><guid>https://blog.youkuaiyun.com/benbmw2008/article/details/38407059</guid><author>benbmw2008</author><pubDate>Wed, 06 Aug 2014 21:36:21 +0800</pubDate><description><![CDATA[选择排序没什么好说的，直接上代码吧
public class SelectSort {
	public void selectSort(int[] in) {
		int inLength = in.length;
		int minIndex = 0;
		for (int i = 0; i < inLength; i++) {
			minIndex = i;
			for (int j =]]></description><category></category></item><item><title><![CDATA[【数据结构与算法】快速排序]]></title><link>https://blog.youkuaiyun.com/benbmw2008/article/details/38401495</link><guid>https://blog.youkuaiyun.com/benbmw2008/article/details/38401495</guid><author>benbmw2008</author><pubDate>Wed, 06 Aug 2014 15:10:14 +0800</pubDate><description><![CDATA[快速排序在同为O(N*logN)的几种排序方法中效率较高，因此经常被采用，再加上快速排序思想----分治法也确实实用，因此很多软件公司的笔试面试，包括像腾讯，微软等知名IT公司都喜欢考这个。
这里对快速排序的原理就不详细叙述了，这篇博客讲的非常好，点击打开链接。
以下是代码：
public class QuickSort {
	public void quickSort(int[] in,]]></description><category></category></item><item><title><![CDATA[【数据结构与算法】冒泡排序]]></title><link>https://blog.youkuaiyun.com/benbmw2008/article/details/38395827</link><guid>https://blog.youkuaiyun.com/benbmw2008/article/details/38395827</guid><author>benbmw2008</author><pubDate>Wed, 06 Aug 2014 10:03:09 +0800</pubDate><description><![CDATA[排序算法是一种基本、常用的算法。怕]]></description><category></category></item></channel></rss>