运用面向对象的分析与设计模式巧解面试算法题

IT行业，千变万化，日新月异，身处其中的各位同仁必感同身受，特别是对从事技术开发的朋友们而言，或许能感觉到唯一不变的就是变化。对纷繁复杂的程序人生而言，其实有一个看不见的主旋律，那就是找工作，找房子，找人（另一半）。如果你是心怀梦想，浪迹于上广北深的千万大军中的一员的话，我想这一句话该是你生活的写照了。在三找中，找工作是其他两找的基础，本系列文章主要是就找工作展开而言。


对开发而言，面试的过程，很多时候就是解算法题，给你一块白板，一支笔，你在白板上写下面试者给你的算法题解。在此，我向大家推荐一个面试算法题网站leetcode oj（https://oj.leetcode.com/），该网站收集了个大著名软件公司的算法题，正在找工作的朋友不妨上去看看。算法面试大概分两部分，一是要做出来，二是要说清楚。很多失败的情况，主要是倒在第二条。说不清楚，除了表达能力外，很重要的一个原因就是算法的设计不不清晰，软件是一个逻辑复杂聚合体，如果做的不清楚，想讲清楚，不太可能，接下来，借用leetcode的一道算法题，讨论一下如何利用面向对象的分析和设计模式给出清晰设计方案。


Validate if a given string is numeric.


Some examples:
"0" => true
" 0.1 " => true
"abc" => false
"1 a" => false
"2e10" => true


Note: It is intended for the problem statement to be ambiguous. You should gather all requirements up front before implementing one.


(https://oj.leetcode.com/problems/valid-number/)


这道题目初看上去很简单，如果你拿到后直接动手，恐怕就危险了，如同它提示所说的，题目一个隐含目的就是模糊性，如果你不对题目仔细分析，并对面试官提出一些减少模糊性的问题就直接动手，那你很可能就已经被pass了。题目要求设计算法，判断字符串是否是数字，数字格式合法性的情况太多了，除了题目给定的例子外，还有很多情况需要搞清楚，例如“00123”是否合法， ".123", "123." 是否是合法的浮点数。而且我们不要以为只要判断给定字符串符合例子格式就可以了，同时还要考虑十六进制格式“0Xabc"是否也是合法的数字格式，罗马数字”I, II, IV"等是否也是合理格式。这道题不但语义模糊，而且具备极高的开放性，扩展性，据说在leetcode上，对该题的测试用例就有1400多个，因此题目看起来简单，但隐藏着很多的陷阱，所以它在leetcode里难度被标记为"Hard". 我们先看看leetcode里一位朋友给的c++解法：

class Solution {
public:
    // can be also solved by DFA
    bool isNumber(const char *s) {
        bool has_dot = false, has_e = false, has_num = false;


        while (*s == ' ') s++;                                  // filter prefix ' '
        if (*s == '-' || *s == '+') s++;                        // filter operator '+' or '-'


        while (*s && *s != ' ') {
            if ((*s == 'e' || *s == 'E') && !has_e) {           // filter 'e'
                has_e = has_dot = true;
                if (!has_num) return false;                     // there should be a number before 'e'
                if (*(s + 1) == '-' || *(s + 1) == '+') s++;
                if (!isdigit(*(s + 1))) return false;
            } else if (*s == '.' && !has_dot) has_dot = true;
            else if (isdigit(*s)) has_num = true;
            else return false;
            s++;
        }


        while (*s) if (*s++ != ' ') return false;               // filter suffix ' '


        return has_num;
    }
};

这是一段简洁的应该是通过了测试的c++解决方案，这段代码是“对”的，但是可能会有一些问题，
一，它的表述性不强，除了作者外，其他人要容易的看懂，估计不容易(其他人也包括面试官)。
 二，代码中有若干注释，大家如果读过Code Complete,  Clean Code 等编程大牛写的书籍，则会意识到，好的代码是不需要注释的，当你需要注释才能解释代码的时候，很可能意味着你的设计不清楚，你的代码有code smell。
第三，将算法逻辑通过很多if else语句柔和起来，调试会复杂，修改一处逻辑很容易引起新的bug。
第四，很难扩展，该解法只处理了问题中给的几个例子，很显然，合理数字不止这三种，如果要添加新的判断功能的话，例如判断十六进制数，那将是困难重重，添加后接下来就是找bug了。如果要是这是面试给出的答案，恐怕要通过的可能性会不高。接下来，我们看看，能否通过面向对象的方法和设计模式给出一个清晰的，可容错，可扩展的解决方案。




根据经典设计模式书 《design patterns, elements of reusable oriented software》。它给出了几条面向对象的设计原则，我们先来看看其中三条:


1. Program to interface， no implementation.


2. Close for modification, open for extension.


3. Encapsulate what varies


根据这几条设计原则，我们一起探讨如何设计一个满足规则的方案，以下的代码基于java实现。首先是program to interface，因此我们先针对问题给出一个对象接口：

interface NumberValidate {


    boolean validate(String s);
}

对实现了该接口的类，只要将字符串输入，它将返回输入字符串是否是合理的数字格式。根据规则3，封装可变的部分，那此处可变的是什么呢，那就是字符串的解析逻辑，整形有自己的解析逻辑，浮点数有自己的解析逻辑，科学计数有自己的解析逻辑，十六进制数有自己的解析逻辑，因此要将这些不同的解析算法封装起来，而不是全部柔和在一起，因此根据这个接口，可以分别派生出以下几个类：


IntegerValidate ， HexValidate ，SienceFormatValidate ，FloatValidate 


各种类型的解析算法分别实现在相应类里，这样就实现了原则3。这种做法有一个好处就是各司其职，逻辑清晰，同时由于封装导致局部化，某一处的修改不会影响到其他部位。假定上述的几个类都实现了，然后我们根据设计模式 Chain of responsibility, 即责任链模式，将他们用一个队列串起来，当要判断给定字符串时，只要将链表上的对象逐个取出，调用validate接口，只要有一个返回true, 那么字符串就是合法的，要不然字符串就非法。该设计模式又满足了第二条原则， 试想如果我们需要再添加对罗马数字的支持，我们只要再实现一个类， RoamNumberValidate, 然后将其加入链表即可，新功能的添加不会对系统造成负面影响。接下来我们看看相应代码实现.

abstract class  NumberValidateTemplate implements NumberValidate{


public boolean validate(String s)
    {
        if (checkStringEmpty(s))
        {
            return false;
        }


        s = checkAndProcessHeader(s);


        if (s.length() == 0)
        {
            return false;
        }


        return doValidate(s);
    }


    private boolean checkStringEmpty(String s)
    {
        if (s.equals(""))
        {
            return true;
        }


        return false;
    }


    private String checkAndProcessHeader(String value)
    {
        value = value.trim();


        if (value.startsWith("+") || value.startsWith("-"))
        {
            value = value.substring(1);
        }




        return value;
    }






    protected abstract boolean doValidate(String s);
}

NumberValidateTemplate 类是一个模板类，对应于书里称之为Template 模式，关于该模式我们以后详谈，该类的主要功能是对输入的字符串做预处理，我想，不需要多说，大家能看懂它的实现逻辑。接下来就是IntegerValidate  等算法实现类的代码：

class IntegerValidate extends NumberValidateTemplate{


    protected boolean doValidate(String integer)
    {
        for (int i = 0; i < integer.length(); i++)
        {
            if(Character.isDigit(integer.charAt(i)) == false)
            {
                return false;
            }
        }


        return true;
    }
}


class HexValidate extends NumberValidateTemplate{


    private char[] valids = new char[] {'a', 'b', 'c', 'd', 'e', 'f'};
    protected boolean doValidate(String hex)
    {
        hex = hex.toLowerCase();
        if (hex.startsWith("0x"))
        {
            hex = hex.substring(2);
        }
        else
        {
            return false;
        }


        for (int i = 0; i < hex.length(); i++)
        {
            if (Character.isDigit(hex.charAt(i)) != true && isValidChar(hex.charAt(i)) != true)
            {
                return false;
            }
        }


        return true;
    }


    private boolean isValidChar(char c)
    {
        for (int i = 0; i < valids.length; i++)
        {
            if (c == valids[i])
            {
                return true;
            }
        }


        return false;
    }
}

这两个类的实现简单，无需太多精力可看懂，对于FloatValidate, 我们只要判断"."前后的内容能通过IntegerValidate即可，由此可见，通过面向对象的设计方法，容易实现代码的重用。

class FloatValidate extends NumberValidateTemplate{


   protected boolean doValidate(String floatVal)
    {
        int pos = floatVal.indexOf(".");
        if (pos == -1)
        {
            return false;
        }


        if (floatVal.length() == 1)
        {
            return false;
        }


        String first = floatVal.substring(0, pos);
        String second = floatVal.substring(pos + 1, floatVal.length());


        if (checkFirstPart(first) == true && checkFirstPart(second) == true)
        {
            return true;
        }


        return false;
    }


    private boolean checkFirstPart(String first)
    {
        if (first.equals("") == false && checkPart(first) == false)
        {
            return false;
        }


        return true;
    }


    private boolean checkPart(String part)
    {
       if (Character.isDigit(part.charAt(0)) == false ||
                Character.isDigit(part.charAt(part.length() - 1)) == false)
        {
            return false;
        }


        NumberValidate nv = new IntegerValidate();
        if (nv.validate(part) == false)
        {
            return false;
        }


        return true;
    }
}

同理，对于SienceFormatValidate ， 只用判断"e"的前半部分满足IntegerValidate, 或FloatValidate, 后半部分满足IntegerValidate即可，可见又是一次代码重用^_^:

class SienceFormatValidate extends NumberValidateTemplate{


protected boolean doValidate(String s)
    {
        s = s.toLowerCase();
        int pos = s.indexOf("e");
        if (pos == -1)
        {
            return false;
        }


        if (s.length() == 1)
        {
            return false;
        }


        String first = s.substring(0, pos);
        String second = s.substring(pos+1, s.length());


        if (validatePartBeforeE(first) == false || validatePartAfterE(second) == false)
        {
            return false;
        }




        return true;
    }


    private boolean validatePartBeforeE(String first)
    {
        if (first.equals("") == true)
        {
            return false;
        }


        if (checkHeadAndEndForSpace(first) == false)
        {
            return false;
        }


        NumberValidate integerValidate = new IntegerValidate();
        NumberValidate floatValidate = new FloatValidate();
        if (integerValidate.validate(first) == false && floatValidate.validate(first) == false)
        {
            return false;
        }


        return true;
    }


private boolean checkHeadAndEndForSpace(String part)
    {


        if (part.startsWith(" ") ||
                part.endsWith(" "))
        {
            return false;
        }


        return true;
    }


    private boolean validatePartAfterE(String second)
    {
        if (second.equals("") == true)
        {
            return false;
        }


        if (checkHeadAndEndForSpace(second) == false)
        {
            return false;
        }


        NumberValidate integerValidate = new IntegerValidate();
        if (integerValidate.validate(second) == false)
        {
            return false;
        }


        return true;
    }
}

接下来用一个链表将他们串联起来：

class NumberValidator implements NumberValidate {


    private ArrayList<NumberValidate> validators = new ArrayList<NumberValidate>();


    public NumberValidator()
    {
        addValidators();
    }


    private  void addValidators()
    {
        NumberValidate nv = new IntegerValidate();
        validators.add(nv);


        nv = new FloatValidate();
        validators.add(nv);


        nv = new HexValidate();
        validators.add(nv);


        nv = new SienceFormatValidate();
        validators.add(nv);
    }


    @Override
    public boolean validate(String s)
    {
        for (NumberValidate nv : validators)
        {
            if (nv.validate(s) == true)
            {
                return true;
            }
        }


        return false;
    }


}

最后，我们看看它用起来多简单：

public class Solution {
    public boolean isNumber(String s) {
        NumberValidate nv = new NumberValidator();


        return nv.validate(s);
    }
}

至此，整个方案就结束了，虽然代码量相比上个方案有所增加，但逻辑上更清晰，扩展性更强，要想增加对罗马数字的支持，再添加一个相应类的实现即可，这也就做到了Close for modification, Open for extension。 该方案很好的包容了题目所蕴含的模糊性，使用这个方案，pass的概率想必会大一些吧。




 作者：陈屹


转载注明出处，谢谢