大二下学业水平测试

大二下学业水平测试

• 两个指针在一定条件下，可以相加

• 类的成员函数：

  • 构造函数，析构函数，拷贝构造函数

  • 友元函数不是类的成员函数

• 面向对象程序设计的三大特性：

  • 封装

  • 继承

  • 多态。

• 冒泡排序补全代码

  for(int  i =0;i<n;i++){
      for(int j =0;j<i;j++){
          if(arr[j]>arr[j+1]){
              swap(arr[j],arr[j+1]);
          }
      }
  }
  

• 汉诺塔问题 ， 移动

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FMBLzs9H-1658160186694)(C:\Users\86189\AppData\Roaming\Typora\typora-user-images\image-20220717220344298.png)]

• 多态的应用性

class shape:{
    
}

class circle: shape{
    
}

int main(){
    int size;
    cin>>size;
    shape;
    circie->draw();
    ~circle();//析构函数
    return 0;
}

• 继承的示例

#include<iostream>
using namespace std;
//基类People
class People {
public:
    void show();
protected:
    char *m_name;
    int m_age;
};
void People::show() {
    cout << m_name << "的年龄是" << m_age << endl;
}
//派生类Student
class Student : public People {
public:
    void learning();
public:
    using People::m_name;  //将protected改为public
    using People::m_age;  //将protected改为public
    float m_score;
private:
    using People::show;  //将public改为private
};
void Student::learning() {
    cout << "我是" << m_name << "，今年" << m_age << "岁，这次考了" << m_score << "分！" << endl;
}
int main() {
    Student stu;
    stu.m_name = "小明";
    stu.m_age = 16;
    stu.m_score = 99.5f;
    stu.show();  //compile error
    stu.learning();
    return 0;
}

template<typename ElemType>
class ArrayList
{
private:
    ElemType *elems;  //数据元素
    int sizeOfElems;  //数据个数
    int sizeOfAllocatedMemory;  //分配内存大小

    static const int INC=10;//内存增量
    void reallocate(); //重新分配内存
public:
    ArrayList(int size=0);  //构造函数
    ArrayList(const ArrayList<ElemType>& list); //拷贝构造函数
    ~ArrayList();  //析构函数
    int size() const; //返回数据个数
    void add(int index, ElemType e); //插入数据
    void add(ElemType e); //插入数据
    void remove(int index); //移除数据
    void remove(); //移除数据
    void clear(); //清除全部数据
    ElemType& operator[](int index); //返回数据
    ArrayList<ElemType>& operator=(const ArrayList<ElemType>& list); //=运算符重载

    
   (ostream& os, const ArrayList<ElemType>& list) //<<运算符重载
    {
        for(int i=0;i<list.size();i++)
            cout<<list.elems[i]<<"\t";
        return os;
    }
};
template<typename ElemType>
ArrayList<ElemType>::ArrayList(int size)
{
    elems=new ElemType[size];
    sizeOfElems=0;
    sizeOfAllocatedMemory=size;
}
template<typename ElemType>
ArrayList<ElemType>::ArrayList( const ArrayList<ElemType>& list )
{
    elems=new ElemType[list.sizeOfAllocatedMemory];
    sizeOfAllocatedMemory=list.sizeOfAllocatedMemory;
    sizeOfElems=list.sizeOfElems;
    for(int i=0;i<list.sizeOfElems;i++)
;
}
template<typename ElemType>
ArrayList<ElemType>::~ArrayList()
{
    delete[] elems;
}
template<typename ElemType>
int ArrayList<ElemType>::size() const
{
    return sizeOfElems;
}
template<typename ElemType>
void ArrayList<ElemType>::reallocate()
{
    int newSizeOfAllocatedMemory=sizeOfAllocatedMemory+INC;
    ElemType *newElems=new ElemType[newSizeOfAllocatedMemory];
    for(int i=0;i<sizeOfElems;i++)
    {
        newElems[i]=elems[i];
    }
    delete []elems;
    elems=newElems;
    sizeOfAllocatedMemory=newSizeOfAllocatedMemory;
}
template<typename ElemType>
void ArrayList<ElemType>::add( int index, ElemType e )
{
    if (index>sizeOfElems) {
        throw string("index out of bounds!");
    }
    int newSizeOfArray=sizeOfElems+1;
    if(sizeOfAllocatedMemory<newSizeOfArray)
    {
        reallocate();
    }
for(int i=sizeOfElems-1;i>=index;i--)
    {
        elems[i+1]=elems[i];
    }
    elems[index]=e;
    sizeOfElems=newSizeOfArray;
}
template<typename ElemType>
void ArrayList<ElemType>::add( ElemType e )
{
    add(this->sizeOfElems,e);
}
template<typename ElemType>
void ArrayList<ElemType>::remove( int index )
{
    int newSizeOfElems=sizeOfElems-1;
    if(index>newSizeOfElems || index<0)
    {
        throw string("index out of bounds!");
    }
    if(sizeOfElems==0)
    {
        throw string("There is no element to remove!");
    }
    for(int i=index;i<newSizeOfElems;i++)
    {
        elems[i]=elems[i+1];

    }
    sizeOfElems=newSizeOfElems;
}
template<typename ElemType>
void ArrayList<ElemType>::remove()
{
    remove(0);
}
template<typename ElemType>
void ArrayList<ElemType>::clear()
{

    
    

• 局部变量可以和成员变量重名

• 数组下标从0开始。

• 线性表频繁地进行不同下标的插入，使用链表更好。

  • “链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。”

• 判断浮点数是否相同的运算虽然符合C语言规则，但是应该尽量避免

• 所有NP完全问题都是NP问题。

• Switch 语句，不一定需要使用break语句。不适用break语句，则所有的case会顺序执行。

• N个节点能构造出多少种不同形态的二叉树：

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eneLToZO-1658160186696)(C:\Users\86189\AppData\Roaming\Typora\typora-user-images\image-20220717233252823.png)]

• 递归函数：

  • 递归函数占用较多的存储空间

  • 递归函数的运行速度不一定很快

  • 递归函数的运行速度一般比较慢

  • 递归函数是自己调用自己。

• 图的广度优先遍历

  • 广度优先搜索

    广度优先搜索类似于树的层次遍历。从图中的某一顶点出发，遍历每一个顶点时，依次遍历其所有的邻接点，然后再从这些邻接点出发，同样依次访问它们的邻接点。按照此过程，直到图中所有被访问过的顶点的邻接点都被访问到。

    最后还需要做的操作就是查看图中是否存在尚未被访问的顶点，若有，则以该顶点为起始点，重复上述遍历的过程。

• 图的深度优先遍历：

  • 深度优先搜索（简称“深搜”或DFS）

    
    图 1 无向图

    深度优先搜索的过程类似于

    树

    的先序遍历，首先从例子中体会深度优先搜索。例如图 1 是一个无向图，采用深度优先算法遍历这个图的过程为：

    1. 首先任意找一个未被遍历过的顶点，例如从 V1 开始，由于 V1 率先访问过了，所以，需要标记 V1 的状态为访问过；
    2. 然后遍历 V1 的邻接点，例如访问 V2 ，并做标记，然后访问 V2 的邻接点，例如 V4 （做标记），然后 V8 ，然后 V5 ；
    3. 当继续遍历 V5 的邻接点时，根据之前做的标记显示，所有邻接点都被访问过了。此时，从 V5 回退到 V8 ，看 V8 是否有未被访问过的邻接点，如果没有，继续回退到 V4 ， V2 ， V1 ；
    4. 通过查看 V1 ，找到一个未被访问过的顶点 V3 ，继续遍历，然后访问 V3 邻接点 V6 ，然后 V7 ；
    5. 由于 V7 没有未被访问的邻接点，所有回退到 V6 ，继续回退至 V3 ，最后到达 V1 ，发现没有未被访问的；
    6. 最后一步需要判断是否所有顶点都被访问，如果还有没被访问的，以未被访问的顶点为第一个顶点，继续依照上边的方式进行遍历。

• 函数

  • C++中不能在一个函数中嵌套定义另一个函数

    程序中每个函数的定义是相互平行和独立的

    C++中不能嵌套定义函数,但是可以嵌套调用函数,即在调用一个函数时,该函数又调用其他函数

    在函数嵌套调用时需要注意:在调用函数之前,需要先声明每一个被调函数(除非被调函数定义在前,调用在后)

• 链表的时间复杂度

  • 在包含n个数据元素的链表中，时间复杂度为O(n)的：

    • 访问第i个元素

    • 删除第i个节点

    • 在i个节点前插入新节点。等

  • C++中不能在一个函数中嵌套定义另一个函数

    程序中每个函数的定义是相互平行和独立的

    C++中不能嵌套定义函数,但是可以嵌套调用函数,即在调用一个函数时,该函数又调用其他函数

    在函数嵌套调用时需要注意:在调用函数之前,需要先声明每一个被调函数(除非被调函数定义在前,调用在后)

• 链表的时间复杂度

  • 在包含n个数据元素的链表中，时间复杂度为O(n)的：

    • 访问第i个元素

    • 删除第i个节点

    • 在i个节点前插入新节点。等