去哪兒

去哪兒三道大題，說難都不難，但是如果不熟可能也寫不好

1 一個數組裡有數字 1,22， 13 ，43.....如何排列組成一個數是最小數，比方說1132243，就是四個數組成的最小數。

當時我的思路就是如何定義比較兩個數大小，肯定是先比最高位，小的排在前面，如果相等在比下一位，如果一直相等，有一個短，那麼短的在前面，之前先把兩個數放到數組中，方便處理。

然後再用一種排序方法調用這個比較方法兩兩比較。

下面代碼是劍指offer中的，思路類似，只是比較方法更巧妙，如果兩個數為m，n，那麼也就是比較mn和nm大小，就是把兩個數串連起來，當然也是存在數組中，小的在前面。

int compare(const void* strNumber1, const void* strNumber2);// int型整數用十進位表示最多隻有10位const int g_MaxNumberLength = 10; char* g_StrCombine1 = new char[g_MaxNumberLength * 2 + 1];char* g_StrCombine2 = new char[g_MaxNumberLength * 2 + 1]; void PrintMinNumber(int* numbers, int length){    if(numbers == NULL || length <= 0)        return;     char** strNumbers = (char**)(new int[length]);    for(int i = 0; i < length; ++i)    {        strNumbers[i] = new char[g_MaxNumberLength + 1];        sprintf(strNumbers[i], "%d", numbers[i]);    }     qsort(strNumbers, length, sizeof(char*), compare);     for(int i = 0; i < length; ++i)        printf("%s", strNumbers[i]);    printf("\n");     for(int i = 0; i < length; ++i)        delete[] strNumbers[i];    delete[] strNumbers;} // 如果[strNumber1][strNumber2] > [strNumber2][strNumber1], 傳回值大於0// 如果[strNumber1][strNumber2] = [strNumber2][strNumber1], 傳回值等於0// 如果[strNumber1][strNumber2] < [strNumber2][strNumber1], 傳回值小於0int compare(const void* strNumber1, const void* strNumber2){    // [strNumber1][strNumber2]    strcpy(g_StrCombine1, *(const char**)strNumber1);    strcat(g_StrCombine1, *(const char**)strNumber2);     // [strNumber2][strNumber1]    strcpy(g_StrCombine2, *(const char**)strNumber2);    strcat(g_StrCombine2, *(const char**)strNumber1);     return strcmp(g_StrCombine1, g_StrCombine2);}

  2 寫一個stl中的stack

以前看過記不太清了

主要應該包括的方法

空建構函式，拷貝建構函式

push，pop，top

emtpy，size等

關係運算子，以及返回常引用等可以略去，準系統一定要實現

成員變數下面代碼就是一個容器，有些地方，用一個指標表示基地址，也就是頭指標，top表示尾指標，還有當前大小，容量等等。相對來說下面代碼用現成容器儲存簡化了很多操作，比較可取。

#pragma once#ifndef _STACK_#define _STACK_#ifndef RC_INVOKED#include <deque>#ifdef _MSC_VER #pragma pack(push,_CRT_PACKING) #pragma warning(push,3)#endif  /* _MSC_VER */_STD_BEGIN        // TEMPLATE CLASS stacktemplate<class _Ty,    class _Container = deque<_Ty> >    class stack    {    // LIFO queue implemented with a containerpublic:    typedef _Container container_type;    typedef typename _Container::value_type value_type;    typedef typename _Container::size_type size_type;    typedef typename _Container::reference reference;    typedef typename _Container::const_reference const_reference;    stack()        : c()        {    // construct with empty container        }    explicit stack(const _Container& _Cont)        : c(_Cont)        {    // construct by copying specified container        }    bool empty() const        {    // test if stack is empty        return (c.empty());        }    size_type size() const        {    // test length of stack        return (c.size());        }    reference top()        {    // return last element of mutable stack        return (c.back());        }    const_reference top() const        {    // return last element of nonmutable stack        return (c.back());        }    void push(const value_type& _Val)        {    // insert element at end        c.push_back(_Val);        }    void pop()        {    // erase last element        c.pop_back();        }    const _Container& _Get_container() const        {    // get reference to container        return (c);        }protected:    _Container c;    // the underlying container    };        // stack TEMPLATE FUNCTIONStemplate<class _Ty,    class _Container> inline    bool operator==(const stack<_Ty, _Container>& _Left,        const stack<_Ty, _Container>& _Right)    {    // test for stack equality    return (_Left._Get_container() == _Right._Get_container());    }template<class _Ty,    class _Container> inline    bool operator!=(const stack<_Ty, _Container>& _Left,        const stack<_Ty, _Container>& _Right)    {    // test for stack inequality    return (!(_Left == _Right));    }template<class _Ty,    class _Container> inline    bool operator<(const stack<_Ty, _Container>& _Left,        const stack<_Ty, _Container>& _Right)    {    // test if _Left < _Right for stacks    return (_Left._Get_container() < _Right._Get_container());    }template<class _Ty,    class _Container> inline    bool operator>(const stack<_Ty, _Container>& _Left,        const stack<_Ty, _Container>& _Right)    {    // test if _Left > _Right for stacks    return (_Right < _Left);    }template<class _Ty,    class _Container> inline    bool operator<=(const stack<_Ty, _Container>& _Left,        const stack<_Ty, _Container>& _Right)    {    // test if _Left <= _Right for stacks    return (!(_Right < _Left));    }template<class _Ty,    class _Container> inline    bool operator>=(const stack<_Ty, _Container>& _Left,        const stack<_Ty, _Container>& _Right)    {    // test if _Left >= _Right for stacks    return (!(_Left < _Right));    }_STD_END#ifdef _MSC_VER #pragma warning(pop) #pragma pack(pop)#endif  /* _MSC_VER */#endif /* RC_INVOKED */#endif /* _STACK_ */

3 利用上面的stack，寫一個算術運算式求值

首先定義一個運算子優先順序表，方便尋找兩個運算子的優先順序大小關係

定義兩個棧，一個儲存運算元，一個儲存運算子

演算法思想：
1。初始化，運算元棧置空；操作符棧壓入'#'。
2。從左往右讀取算術運算式（從第二個字元開始），當讀到'#'且操作符棧棧頂也是'#'時則演算法結束。
3。如果讀到的是運算元則壓入運算元棧中，轉到步驟2。
4。如果讀到是操作符，則比較其與操作符棧棧頂操作符的優先順序。
5。如果棧頂操作符的優先順序高，則棧頂操作符出棧，並從運算元棧中彈出兩個運算元進行相應的運算，再把運

算結果壓入運算元棧中，轉至步驟4。
6。如果棧頂操作符的優先順序低，則把當前操作符壓入操作符棧，轉至步驟2。
7。如果棧頂操作符與當前操作符優先順序相同，則只可能是'('跟')'，把操作符從棧中彈出即可，轉至步驟2。

詳細演算法http://blog.csdn.net/bluesky_03/article/details/2900289

和嚴老師資料結構教程的差不多。