剑指offer面试案例汇总（1-5）

最新推荐文章于 2024-05-03 23:41:06 发布

我的喵喵找不到了

最新推荐文章于 2024-05-03 23:41:06 发布

阅读量275

点赞数

文章标签： C++

本文链接：https://blog.csdn.net/qq_30050175/article/details/87923025

版权

剑指offer面试案例汇总（1-5）

https://github.com/zhedahht/CodingInterviewChinese2/tree/master

面试题1

如下为类型CMyString的声明，请为该类型添加赋值运算符函数
class CMyString
{
public:
		CMyString(char * pData = nullptr);
		CMyString(const CMyString& str);
		~CMyString(void);
private:
		char* m_pData;
};

知识点

C++的赋值运算符重载函数(operator=)：
赋值运算符重载函数(operator=)

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

class MyStr
{
private:
    char *name;
    int id;
public:
    MyStr() {}
    MyStr(int _id, char *_name)   //constructor
    {
        cout << "constructor" << endl;
        id = _id;
        name = new char[strlen(_name) + 1];
        strcpy_s(name, strlen(_name) + 1, _name);
    }
    MyStr(const MyStr& str)
    {
        cout << "copy constructor" << endl;
        id = str.id;
        if (name != NULL)
            delete[] name;
        name = new char[strlen(str.name) + 1];
        strcpy_s(name, strlen(str.name) + 1, str.name);
    }
    MyStr& operator =(const MyStr& str)//赋值运算符
    {
        cout << "operator =" << endl;
        if (this != &str)
        {
            if (name != NULL)
                delete[] name;
                /**
				深拷贝和浅拷贝，若不delete，指向同一块内存空间
				**/
            this->id = str.id;
            int len = strlen(str.name);
            name = new char[len + 1];
            strcpy_s(name, strlen(str.name) + 1, str.name);
        }
        return *this;
    }
    ~MyStr()
    {
        delete[] name;
    }
};

int main()
{
    MyStr str1(1, "hhxx");
    cout << "====================" << endl;
    MyStr str2;
    str2 = str1;
    cout << "====================" << endl;
    MyStr str3 = str2;
    return 0;
}

参数：赋值运算符重载函数的参数是函数所在类的const类型的引用；
返回值：返回值是被赋值者的引用；
调用：当为一个类对象赋值（注意：可以用本类对象为其赋值】，也可以用其它类型（如内置类型）的值为其赋值时，会由该对象调用该类的赋值运算符重载函数。
eg.str2 = str1;一句，用str1为str2赋值，会由str2调用MyStr类的赋值运算符重载函数。

但是：

MyStr str2;
str2 = str1;

和

MyStr str3 = str2;

前者MyStr str2;一句是str2的声明加定义，调用无参构造函数，所以str2 = str1;一句是在str2已经存在的情况下，用str1来为str2赋值，调用的是拷贝赋值运算符重载函数；而后者，是用str2来初始化str3，调用的是拷贝构造函数

提供默认赋值运算符重载函数的时机：当程序没有显式地提供一个以本类或本类的引用为参数的赋值运算符重载函数时，编译器会自动生成这样一个赋值运算符重载函数。

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

class Data
{
private:
    int data;
public:
    Data() {};
    Data(int _data)
        :data(_data)
    {
        cout << "constructor" << endl;
    }
    Data& operator=(const int _data)
    {
        cout << "operator=(int _data)" << endl;
        data = _data;
        return *this;
    }
};

int main()
{
    Data data1(1);
    Data data2,data3;
    cout << "=====================" << endl;
    data2 = 1;//int型参数的赋值运算符重载函数
    cout << "=====================" << endl;
    data3 = data2;
    return 0;
}

结果：
在这里插入图片描述

将上面例子中的赋值运算符重载函数注释掉：
在这里插入图片描述

当用一个非类A的值（如上面的int型值）为类A的对象赋值时

①如果匹配的构造函数和赋值运算符重载函数同时存在（如例2），会调用赋值运算符重载函数。

②如果只有匹配的构造函数存在，就会调用这个构造函数。

赋值运算符重载函数只能是类的非静态的成员函数：避免二义性
赋值运算符重载函数不能被继承：

operator

operator作类的转换函数：类可以使用构造函数将其他类型转化为此类的对象

#include <iostream>

using namespace std;

class my_class
{
public:
    operator int()//定义了一个将类转化为int的转换函数
    {
        cout << "convert_to_int" << endl;
        return 1;
    }
};

int main()
{
    my_class a;
    int i_a = (int)a;//第一次显式的转换
    cout << a << endl;//第二次隐式的转换

    return 0;
}

operator在类中重载运算符
- 类型转换：operator <类型>()
- 运算符重载：<类型> operator <运算符>(<参数表>)

#include <iostream>

using namespace std;

class MyClass
{
public:
    MyClass() {}
    MyClass(int a, double b):a_(a),b_(b){}
    ~MyClass(){}

    int get_a() { return a_; }
    double get_b() { return b_; }

    MyClass operator+(const MyClass &adder) const//以成员函数方式重载+
    {
        MyClass sum;
        sum.a_ = a_ + adder.a_;
        sum.b_ = b_ + adder.b_;
        return sum;
    }

    friend MyClass operator-(const MyClass &A,const MyClass &B)//以友元方式重载-
    {
        MyClass diff;
        diff.a_ = A.a_ - B.a_;
        diff.b_ = A.b_ - B.b_;
        return diff;
    }

private:
    int a_;
    double b_;
};


int main()
{
    MyClass A(1, 1.1);
    MyClass B(2, 2.2);
    MyClass sum = A + B;
    MyClass diff = A - B;
    cout << sum.get_a() << "\t" << sum.get_b() << endl;
    cout << diff.get_a() << "\t" << diff.get_b() << endl;

    return 0;
}

解题思路

考察点

返回值类型声明为该类型的引用
传入参数类型声明为常量引用（形参到实参会调用一次复制构造函数+const）
释放实例自身已有的内存
判断传入参数和当前是否是同一个实例

答案
= = 我的

CMyString& operator(const CMyString& str)
{
   if(this != &str)
   {
   		if(m_pData != NULL)
   		{
   				delete [] m_pData;
   		 }
   		 len = strlen(str.m_pData);
   		 m_pData = new char [len+1];
   		 strcpy_s(m_pData, strlen(str.m_pData)+1, str.m_pData);
   }
   return *this;
}

书上简易答案：

CMyString& CMyString::operator=(const CMyString &str)
{
	if(this == &str)
		return *this;
	delete [] m_pData;
	m_pData = nullptr;
	
	m_pData = new char[strlen(str.m_pData+1)];
	strcpy(m_pData, str.m_pData);

	return *this;
}

进阶：高级

new char内存不足导致m_pData空指针程序崩溃
解决：
①先new后delete保证CMyString的实例不被修改
②创建临时实例

CMyString& CMyString::operator=(const CMyString& str)
{
	if(this != &str)
	{
		CMyString strTemp(str);

		char * pTemp = strTemp.m_pData;
		strTemp.m_pData = m_pData;
		m_pData = pTemp;
	}
	return *this;
}

补充

引用：类型标识符 &引用名=目标变量名

引用作为参数：在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效率和所占空间都好。

void swap(int& x, int& y);
swap(a, b);

引用作返回值：不能返回局部变量的引用，可以返回类成员的引用，但最好是const，引用与一些操作符的重载：流操作符<<和>>，这两个操作符常常希望被连续使用

double vals[] = {10.1, 12.6, 33.1, 24.1, 50.0};

double& setValues( int i )
{
  return vals[i];   // 返回第 i 个元素的引用
}

setValues(1) = 20.23;//修改了valsp[1]的值

面试题2

C#跳过

面试题3

题目：找出数组中重复的数字
在一个长度为n的数组里的所有数字都在0～n-1的范围中。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意重复的数字。
例如：如果输入长度为7的数组{2，3，1，0，2，5，3}，那么对应的输出是重复的数字2或3

解题思路

排序+扫描数组

归并排序 $n l o g n$ ，扫描 $n$

哈希表

从头到尾扫描判断哈希表中是否包含此数字。若是否，加入哈希表

扫描

利用下标i和数字m，若m=i，i=i+1；若不同，比较第m上的数字，相同则重复，不同则交换位置；
{2,3,1,0,2,5,3}
{1,3,2,0,2,5,3}
{3,1,2,0,2,5,3}
{0,1,2,3,2,5,3}
比较i=5的2，找到重复。

我的代码


#include<iostream>

using namespace std;

int find(int A[], int size)
{
    int tmp = 0, result = -1 , i=0;
    int x=0;
    while(i<size)
    {
        x = A[i];
        if(i == x)
        {
            i++;
        }
        else
        {
            if(A[x] == x)
            {
                result = x;
                break;
            }
            else
            {
                tmp = x;
                A[i] = A[x];
                A[x] = tmp;
            }
        }
    }
    return result;
}

int main()
{
    int A[]={2,3,1,0,2,5,3};
    int size = 0;
    size = sizeof(A)/sizeof(A[0]);
    int a = find(A, size);
    cout<<a<<endl;
}

书上代码

// 参数:
//        numbers:     一个整数数组
//        length:      数组的长度
//        duplication: (输出) 数组中的一个重复的数字
// 返回值:             
//        true  - 输入有效，并且数组中存在重复的数字
//        false - 输入无效，或者数组中没有重复的数字

bool duplicate(int numbers[], int length, int* duplication)
{
    if(numbers == nullptr || length <= 0)
        return false;

    for(int i = 0; i < length; ++i)
    {
        if(numbers[i] < 0 || numbers[i] > length - 1)
            return false;
    }

    for(int i = 0; i < length; ++i)
    {
        while(numbers[i] != i)
        {
            if(numbers[i] == numbers[numbers[i]])
            {
                *duplication = numbers[i];
                return true;
            }

            // 交换numbers[i]和numbers[numbers[i]]             
            int temp = numbers[i];
            numbers[i] = numbers[temp];
            numbers[temp] = temp;
        }
    }

    return false;
}

注意异常判断！

改进

不修改数组找出重复的数字
在一个长度为n+1的数组里的所有数字都在1～n的范围内，所以数字中至少有一个数字是重复的。请找出数组中任意一个重复的数字，但不能修改输入数组。
例如：如果输入长度是8的数组{2,3,5,4,3,2,6,7}，那么对应的输出重复数字2或者3

同上，新创建数组，下标对应，逐一放入

解题方法：分两部分
{2,3,5,4,3,2,6,7}
这些数字的范围一定在1～7内，分为1～4，5～7
1～4区间的数字在数组出现了5次，有重复
1～2，3～4分别为2，3
3，4

代码

#include <iostream>

int countRange(const int* numbers, int length, int start, int end);

// 参数:
//        numbers:     一个整数数组
//        length:      数组的长度
// 返回值:             
//        正数  - 输入有效，并且数组中存在重复的数字，返回值为重复的数字
//        负数  - 输入无效，或者数组中没有重复的数字
int getDuplication(const int* numbers, int length)
{
    if(numbers == nullptr || length <= 0)
        return -1;

    int start = 1;
    int end = length - 1;
    while(end >= start)
    {
        int middle = ((end - start) >> 1) + start;
        int count = countRange(numbers, length, start, middle);
        if(end == start)
        {
            if(count > 1)
                return start;
            else
                break;
        }

        if(count > (middle - start + 1))
            end = middle;
        else
            start = middle + 1;
    }
    return -1;
}

int countRange(const int* numbers, int length, int start, int end)
{
    if(numbers == nullptr)
        return 0;

    int count = 0;
    for(int i = 0; i < length; i++)
        if(numbers[i] >= start && numbers[i] <= end)
            ++count;
    return count;
}

面试题4

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

思路：首先选取数组中右上角的数字，如果该数字等于要查找的数字，则查找过程结束；大于剔除一列，小于剔除一行

我的

/**
num，A[n][m], i, j
i = 0, j = m-1;
循环：
	if(num > A[i][j]) i++
	else if(num < A[i][j]) j--
	else return true
**/

bool FindNum(vector<vector<int> >A, int n, int m, int e)
{
    int i=0, j=m-1;
    while(i<n && j>=0)
    {
        if(e>A[i][j])   i++;
        else if (e<A[i][j])     j--;
        else return true;
    }
    return false;
}

书上

bool Find(int * matrix, int rows. int columns, int number)
{
	bool found = false;

	if(matrix !=nullptr && row>0 && columns >0)
	{
		int row = 0;
		int column = coluns-1;
		while(row < rows && column>=0)
		{
			if(matrix[row*columns + column] == number)
			{
				found = true;
				break;
			}
			else if(matrix[row *columns + column]>number)
			{
				--column;
			}
			else ++row;
		}
	}
	return found;
}

面试题5

请实现一个函数，把字符串中的每个空格替换成"%20"。
例如：输入“We are happy”，则输出“We =%20are%happy”

    string str = "We are happy";
    const char *s = "%20";
    for(int i=0; i<str.length(); i++)
    {
        cout<<str[i]<<endl;
        if(str[i] == ' ')
        {
            
            str.erase(i,1);
            str.insert(i, s);
        }
    }

上种方法时间复杂度高
时间复杂度 $O (n)$ 思路：

遍历字符串，统计空格总数，计算新的字符串长度；
从字符串后面换。定义两个指针，p1指向旧字符串尾部，p2指向新字符串尾部；
p1向前走，逐个把它指向的字符复制给p2；若遇到空格，p1向前移，在p2之前插入“%20”。p2向前移动3格；
知道空格替换完毕为止

void ReplaceBlank(char string[], int length)
{
    if(string == nullptr || length <= 0)
    {
        return;
    }
    
    int originalLength = 0;
    int numberOfBlank = 0;
    
    char *p1, *p2;
    int i=0;
    
    while(string[i]!='\0')
    {
        ++originalLength;
        if(string[i] == ' ')
        {
            ++numberOfBlank;
        }
        ++i;
    }
    
    int newLength = originalLength + 2*numberOfBlank;
    if(newLength>length)
    {
        return;
    }
    
    int indexOfOriginal = originalLength;
    int indexOfNew = newLength;
    
    while(indexOfOriginal >=0 && indexOfNew > indexOfOriginal)
    {
        if(string[indexOfOriginal] == ' ')
        {
            string[indexOfNew--] = '0';
            string[indexOfNew--] = '2';
            string[indexOfNew--] = '%';
            
        }
        else
        {
            string[indexOfNew--] = string[indexOfOriginal];
        }
        --indexOfOriginal;
    }
        
}

扩展

有两个排序数组A1和A2，内存在A1的末尾有足够多的空余空间容纳A2。请实现一个函数，把A2中的所有数字插入A1中，并且所有的数字都是排序的。

从后往前的思路


void fun(int a[],int len1,int b[],int len2)
{
	int i = len1+len2;
	i--;
	len1--;
	len2--;
	while(len1>=0&&len2>=0)
	{
		if (a[len1]>=b[len2])
		{
		a[i--] = a[len1--];
		}
		else
		{
			a[i--] = b[len2--];
		}
	}
	while(len1>=0)
	{
	a[i--] = a[len1--];
	}
	while (len2>=0)
	{
	a[i--] = b[len2--];
	}