笔试刷题总结

今天刷了一些笔试题，以下是刷完笔试题后看到的相关知识点的解析，做个小结。

1、多态主要以两种形式，静态多态和动态多态，静态多态主要实现了函数重载和运算符重载。动态多态主要实现了虚函数。虚函数是动态联编，程序在运行的过程中确定调用哪一个函数。

2、int *s[8]; //定义一个指针数组，该数组中每个元素是一个指针，每个指针指向哪里就需要程序中后续再定义了。
int (*s)[8]; //定义一个数组指针，该指针指向含8个元素的一维数组（数组中每个元素是int型）。

区分int *p[n]; 和int (*p)[n]; 就要看运算符的优先级了。
int *p[n]; 中，运算符[ ]优先级高，先与p结合成为一个数组，再由int*说明这是一个整型指针数组。
int (*p)[n]; 中( )优先级高，首先说明p是一个指针，指向一个整型的一维数组。

3、计算机系统中，从内到外，硬件系统，操作系统，支撑软件，应用软件。

下面是笔试题的编程练习：

题目1：

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        if(array.empty()) return false;
        int row = array.size();//行
        int column = array[0].size();//列
        for(int i = 0; i < row; i++)
        {
            int left = 0;
            int right = column - 1;
            while(left <= right)
            {
                int mid = (left + right) / 2;
                if(target < array[i][mid])
                {
                    right = mid - 1;
                }
                else if(target > array[i][mid])
                {
                    left = mid + 1;
                }
                else
                {
                    return true;
                }              
            }
        }
        return false;
    }
};

题目2：

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。

n<=39

class Solution {
public:
    int Fibonacci(int n) {
        int f[40];
        f[0] = 0;
        f[1] = 1;
        for(int i = 2; i <= n; i++)
        {
            f[i] = f[i - 1] + f[i - 2];
        }
        return f[n];
    }
};

题目3：

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        if(array.empty()) return false;
        int row = array.size();//行
        int column = array[0].size();//列
        for(int i = 0; i < row; i++)
        {
            int left = 0;
            int right = column - 1;
            while(left <= right)
            {
                int mid = (left + right) / 2;
                if(target < array[i][mid])
                {
                    right = mid - 1;
                }
                else if(target > array[i][mid])
                {
                    left = mid + 1;
                }
                else
                {
                    return true;
                }              
            }
        }
        return false;
    }
};

题目4：

输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        vector<int> array;
        if(head == NULL) return array;
        stack<int> s;
        ListNode* p = head;
        while(p != NULL) {
            s.push(p->val);
            p = p->next;
        }
        while(!s.empty()) {
            array.push_back(s.top());
            s.pop();
        }
        return array;
    }
};
添加笔记

猜你喜欢