面试笔记

1.python用类实现斐波那契数列

# coding=utf-8
"""用类实现斐波那契数列"""

class Fib():
    def __call__(self, *args, **kwargs):
        ret = [1,1]
        num = int(args[0])
        if num == 1:
            return [1,]
        else:
            while len(ret)< num:
                ret.append(ret[-1]+ret[-2])
            return ret

fib = Fib()
print(fib(5))
==>
[1, 1, 2, 3, 5]

实现了__call__方法的对象，相当于重载了（），可以实现调用功能。

__call__方法的参数就是调用实例时需要的参数。

2.map实现删除

#include <iostream>
#include <map>
using namespace std;


int main()
{
    map<int, int> test_map;
    test_map[1] = 1;
    test_map[2] = 2;
    test_map[3] = 3;
    test_map[4] = 4;   
    for( std::map<int, int>::iterator iter = test_map.begin();
        iter != test_map.end(); ++ iter )
    {
        cout << iter->first << " " << iter->second << endl;
    }
    
    int count = 0;
    
    // delete the element
    for( std::map<int, int>::iterator iter = test_map.begin();
        iter != test_map.end(); )
    {
        std::map<int, int>::iterator it_back = iter;
        bool is_first_element = false;
        if(it_back != test_map.begin())
        it_back --;
        else
        is_first_element = true;
        
        // delete the element that matches the specific condition
        if( iter->first % 2 == 0)
        {
            test_map.erase(iter);           
            if(is_first_element)
             iter = test_map.begin();
            else
                iter = ++ it_back;
        }else iter ++;      
        
        count ++;
    }
    
    cout << "use count:" << count << endl;
 
    cout << "after delete " << endl;
    
    for( std::map<int, int>::iterator iter = test_map.begin();
        iter != test_map.end(); ++ iter)
    {
        cout << iter->first << " " << iter->second << endl;
    }
    
    system("pause");
    return 0;
     
}

3.实现vector

#include <iostream>
using namespace std;

template<class T>
class vector
{
private:
	int sz;  //数组已用长度
	T* elem;   //指向元素的指针
	int space;  //已用大小+空闲空间
public:
	vector(initializer_list<T>lst) :sz{ lst.size() }, elem{ new T[sz] }   //实现 vector<int>v = {1,3}这种初始化赋值操作
	{
		copy(lst.begin(), lst.end(), elem);
	}
	vector() : sz{ 0 }, elem{ nullptr }, space{ 0 } {}  //默认构造函数
	vector(const vector<T>&arg) :sz{ arg.sz }, elem{ new T[arg.sz] } //拷贝构造函数实现深拷贝
	{
		copy(arg.elem, arg.elem + arg.sz, elem);
	}
	vector& operator = (const vector& a);  //拷贝赋值


	explicit vector(int s) :sz{ s }, elem{ new T[s] }   //单参数的构造函数加explicit防止隐式赋值
	{
		for (int i = 0; i < sz; i++)
			elem[i] = 0;
	}
	~vector(){ delete[] elem; }  //析构函数
	T & operator[](int i)  //运算符重载实现v[i]=5这种形式，引用为了返回一个地址
	{
		if (i > sz)
		{
			cout << "越界访问了" << endl;  
		}
		return elem[i];
	}
	const T operator[](int n) const   //给const vector<T>s这种形式用的
	{
		return elem[n];
	}
	int size() const{ return sz; }  //返回vector长度
	vector(vector&& a)   //移动构造函数
	{
		a.sz = 0;
		a.elem = nullptr;
	}
	vector& operator = (vector&&) //移动赋值
	{
		delete[] elem;
		elem = a.elem;
		sz = a.sz;
		a.elem = nullptr;
		a.sz = 0;
		return *this;
	}
	int capacity() const { return space; }  //总空间大小
	void reserve(int newalloc);  //增加空间
	void resize(int newsize);    //改变长度
	void push_back(const T&d);   
};

template<class T>
void vector<T>::reserve(int newalloc)  //newalloc是新的长度
{
	if (newalloc <= space) return;
	T* p = new T[newalloc];
	for (int i = 0; i < sz; i++) p[i] = elem[i];
	delete[]elem;
	elem = p;
	space = newalloc;
}

template<class T>
void vector<T>::resize(int newsize)
{
	reserve(newsize);
	for (int i = sz; i<newsize; ++i) elem[i] = 0;    //初始化新元素
	sz = newsize;
}

template<class T>
void vector<T>::push_back(const T&d)
{
	if (space == 0)
		reserve(sizeof(d));
	else if (space == sz)
		reserve(2 * space);

	elem[sz] = d;    //添加元素
	++sz;            //更新长度
}


template <class T>
typename vector<T>& vector<T>::operator=(const vector<T>& a)//拷贝赋值
{
	if (this == &a) return *this;    // 自我赋值毫无意义

	if (a.sz <= space) {             // space足够,不用分配新空间
		for (int i = 0; i < a.sz; ++i) elem[i] = a.elem[i]; // 直接拷贝元素就行
		sz = a.sz;
		return *this;
	}

	T* p = new T[a.sz];  // 分配新元素
	for (int i = 0; i < a.sz; ++i) p[i] = a.elem[i];    // 拷贝元素
	delete[] elem;                // 释放旧空间
	space = sz = a.sz;             // 设置新大小
	elem = p;                      // 设置新元素指针
	return *this;                  // 返回自引用
}

int main()
{
	vector<int>v(3);
	vector<int>v2 = v;
	vector<int>k = { 1, 3};
	cout << v2[0] << endl;
	v.push_back(3);
	cout << v.size() << endl;
	cout << k.size() << endl;
	return 0;
}