1

斐波那契数列

// 
int Fib1(int n)
{
    if (n < 3)
        return 1;
    return Fib1(n - 1) + Fib1(n - 2);
}
int main()
{
    cout << Fib1(10) << endl;
    getchar();
    return 0;
}

//循环
int Fib2(int n)
{
    int x = 1;
    int y = 1;
    int ret = 1;
    for (int i = 3; i <= n; i++)
    {
        ret = x + y;
        x = y;
        y = ret;
    }
    return ret;
}
int main()
{
    cout << Fib2(5) << endl;
    getchar();
    return 0;
}

// 尾递归
int Fib(int first,int second,int N)
{
    if (N < 3)
        return 1;
    if (N == 3)
        return first + second;
    return Fib(second, first + second, N - 1);
}
int main()
{
    cout << Fib(1, 1, 5) << endl;
    getchar();
    return 0;
}

模拟静态Stack

#define MAX 10
template<class T>
class Stack
{
public:
    Stack()
        :_size(0)
    {}
    Stack(T* array, int size)
    {
        for (int i = 0; i < size; i++)
        {
            _array[i] = array[i];
        }
        _size = size;
    }
    void Push(T data)
    {
        if (_size < MAX)
        {
            _array[_size++] = data;
        }
    }
    void Pop()
    {
        if (_size)
        --_size;
    }
    T& Top()
    {
        return array[_size];
    }
    friend ostream& operator<<(ostream& _cout, const Stack& s)
    {
        for (int i = 0; i < s._size; i++)
        {
            _cout << s._array[i] << " ";
        }
        _cout << endl;
        return _cout;
    }
    ~Stack()
    {

    }
private:
    //T _data;
    T _array[MAX];
    int _size;
};
int main()
{
    int array[] = { 0, 1, 2, 3, 4 };
    Stack<int> s1(array, sizeof(array) / sizeof(array[0]));
    cout << s1 << endl;

    s1.Push(5);
    cout << s1 << endl;
    s1.Push(6);
    cout << s1 << endl;

    s1.Pop();
    s1.Pop();
    s1.Pop();
    s1.Pop();
    s1.Pop();
    s1.Pop();
    cout << s1 << endl;
    s1.Pop();
    cout << s1 << endl;
    s1.Pop();
    cout << s1 << endl;

    Stack<int> s2;
    s2.Push(1);
    s2.Push(2);
    cout << s2 << endl;
    getchar();
    return 0;
}

动态 Stack

template<class T>
class Stack
{
public:
    Stack()
        :_size(0)
        , _capacity(0)
        , _array(NULL)
    {}
    Stack(T* array, int size)
    {
        _array = new T[sizeof(T)*size];
        for (int i = 0; i < size; i++)
        {
            _array[i] = array[i];
        }
        _size = size;
        _capacity=size;
    }
    void Push(T data)
    {
        if (_size>=_capacity)
            CheckCapacity();
        _array[_size++] = data;
    }
    void Pop()
    {
        if (_size)
            --_size;
    }
    void CheckCapacity()
    {
        if (_size < _capacity)
            return;
        int newcapacity = _capacity ? _capacity * 2 : 3;
        T* newarray = new T[newcapacity*sizeof(T)]; 
        for (int i = 0; i < _size; i++)
        {
            newarray[i] = _array[i];
        }
        delete[] _array;
        _array = newarray;
        _capacity = newcapacity;
    }
    T& Top()
    {
        return array[_size];
    }
    friend ostream& operator<<(ostream& _cout, const Stack& s)
    {
        for (int i = 0; i < s._size; i++)
        {
            _cout << s._array[i] << " ";
        }
        _cout << endl;
        return _cout;
    }
    ~Stack()
    {
        if (_array)
            delete[] _array;
        _array = NULL;
    }
private:
    //T _data;
    T *_array;
    int _size;
    int _capacity;
};
int main()
{
    int array[] = { 0, 1, 2, 3, 4 };
    Stack<int> s1(array, sizeof(array) / sizeof(array[0]));
    cout << s1 << endl;

    s1.Push(5);
    cout << s1 << endl;
    s1.Push(6);
    cout << s1 << endl;
    s1.Push(7);
    s1.Push(8);
    cout << s1 << endl;
    s1.Push(9);
    s1.Push(10);
    s1.Push(11);
    cout << s1 << endl;

    s1.Pop();
    s1.Pop();
    s1.Pop();
    s1.Pop();
    s1.Pop();
    s1.Pop();
    cout << s1 << endl;
    s1.Pop();
    cout << s1 << endl;
    s1.Pop();
    cout << s1 << endl;

    Stack<int> s2;
    s2.Push(1);
    s2.Push(2);
    cout << s2 << endl;
    getchar();
    return 0;
}