Happy剑指offer：第2章题目笔记

概念题

定义一个空的类，里面没有任何成员变量和成员函数。对该类型求sizeof，会得到的结果是1。因为虽然没有成员变量和成员函数，没有有用信息，但是声明实例的时候，它必须在内存之中占用一定的空间，空间的大小由编译器决定，Visual Studio其分配空间为1。哪怕类内定义了构造函数和析构函数，这个结果仍然不会改变，仍然会是1。因为在实例需要初始化或者析构的时候，只需要调用这两个函数，即取得这两个函数的地址即可。这两个函数不会为实例增添任何内容。

在上面的例子之中，如果把析构函数构造成虚函数，那么结果会发生变化。这是因为编译器一旦发现类之中有虚函数，那么它一定会生成一个指向虚函数的虚函数表。在虚函数表之中，生成一个指向虚函数表的指针，指针的大小随系统的位数决定。32位系统指针占用4个字节，求sizeof之后，结果为4，64为系统占用8个字节，最终结果为8 。

判断题1

涉及到的一个问题是类内赋值构造函数的传值问题。如果允许复制构造函数传值，就会在赋值构造函数内部递归一般的进行对复制构造函数的调用，最终必然导致栈溢出。

如果仔细观察就会发现，如果要是调用复制构造函数，赋值构造函数的输入参数必然是引用形式。

举例；

A(const A &other)

面试题1

自己在定义一个类的时候，对构造函数，仍然会有一点点的不确定。

尝试了一把运算符重载。感觉还好，注意的是

1. 输入为引用，输出为引用

2. 对于指针，注意分配内存和释放内存。

内存泄露指的是在定义指针之后为其动态分配了内存，但是在使用完毕之后并未释放该内存。导致该内存一直被占用。其实说白了就是该内存空间使用完毕之后未回收。

//offer1
class CMyString
{
public:CMyString(char* pData = NULL);//这个应该只能算是声明吧CMyString(const CMyString& str);~CMyString(void);CMyString& operator =(const CMyString &str);
private:char* m_pData;
};
CMyString& CMyString::operator = (const CMyString &str)
{if (this == &str)return *this;delete[]m_pData;m_pData == NULL;m_pData = new char[strlen(str.m_pData) + 1];strcpy(m_pData, str.m_pData);return *this;
}

面试题2

singleton模式：即单例模式。数学与逻辑学中，singleton定义为“有且仅有一个元素的集合”

如果一个类和singleton模式相关联，那么毫无疑问，这是一个特殊类，因为这种类只有一个对象，所以称为单例，单个例子嘛。一般这种单例非常容易被外界访问。

优点：节约系统资源。

生成实例的方法是静态方法。

//offer2 实现singleton模式
class Singleton
{
public:static Singleton& GetInstance(){static Singleton Instance;return Instance;}
private:Singleton();Singleton(const Singleton& other);~Singleton();Singleton& operator=(const Singleton& other);
};

面试题3

注意int* matrix只能是代表一维数组。思路知道之后这道题突然间变得好简单。

//offer3
bool Find(int* matrix, int rows, int columns, int number)
{bool IsFound = false;if (matrix != NULL && rows > 0 && columns > 0){int row = rows-1;int column = 0;while (row >= 0 && column < columns){if (matrix[row*columns + column] == number){IsFound = true;break;}else{if (matrix[row*columns + column] < number){++column;}else{--row;}}}}return IsFound;
}

判断题2：

两个字符串均定义为char str[]类型的时候，判断两个字符串是否相等，需要判定两个是不是指向相同的内存空间。这个问题十分重要。并非内容一样就可以的。另一种：char* str就不存在这个问题。它们定义的时候会自动指向对应的内存地址的。

面试题4：

//offer4
void ReplaceBlank(char str[], int length)
{if (str == NULL || length < 0)return;int LengthOriginal = strlen(str);int LengthNew = LengthOriginal;int i = 0;while (str[i] != '\0'){if (str[i] == ' '){LengthNew += 2;}++i;}int IndexOri = LengthOriginal;int IndexNew = LengthNew;while (IndexOri >= 0 && IndexNew > IndexOri)//IndexNew>IndexOri如果前面一大片都没有空格的话，那么这个判断可以节约很多时间
    {if (str[IndexOri] == ' '){str[IndexNew--] = '0';str[IndexNew--] = '2';str[IndexNew--] = '%';}elsestr[IndexNew--] = str[IndexOri];IndexOri--;}
}

面试题4附加题

void InerstNumber(int* arr1, int length1,int* arr2, int length2,int length)
{if (arr1 == NULL || length < 0)return;if (arr2 == NULL){arr2 = arr1;return;}if (length1 + length2>length)return;int index1 = length1-1;int index2 = length2-1;int index3 = length1 + length2-1;while (index1>=0&&index2>=0&&index3 >=0 ){if (arr1[index1] > arr2[index2]){arr2[index3--] = arr1[index1--];}else if (arr1[index1] < arr2[index2]){arr2[index3--] = arr2[index2--];}else{arr2[index3--] = arr2[index2--];arr2[index3--] = arr1[index1--];}}if (index2 < 0){while (index1>=0)arr2[index3--] = arr1[index1--];}
}

在链表的尾部添加结点

void AddToTail(ListNode **pHead, int value)
{ListNode* pNew = new ListNode();pNew->m_nValue = value;pNew->m_pNext = NULL;if (*pHead == NULL){*pHead = pNew;}else{ListNode* pNode = *pHead;while (pNode->m_pNext != NULL)pNode = pNode->m_pNext;pNode->m_pNext = pNew;}
}

删除一个节点

void RemoveNode(ListNode** pHead, int value)
{if (pHead == NULL || *pHead == NULL)return;ListNode* pToBeDeleted;if ((*pHead)->m_nValue == value){pToBeDeleted = *pHead;*pHead = (*pHead)->m_pNext;}else{ListNode* pNode = *pHead;while (pNode->m_pNext != NULL&&pNode->m_pNext->m_nValue != value)pNode = pNode->m_pNext;if (pNode->m_pNext != NULL&&pNode->m_pNext->m_nValue == value){pToBeDeleted = pNode->m_pNext;pNode->m_pNext = pNode->m_pNext->m_pNext;}}if (pToBeDeleted != NULL){delete pToBeDeleted;pToBeDeleted = NULL;}
}

面试题5从尾到头打印链表。这道题可以在栈的帮助下用迭代的方式实现。或者使用递归方式实现。

迭代方式：

void PrintListNode(ListNode* pHead)
{if (pHead == NULL)return;ListNode* pNode = pHead;stack<ListNode*> nodes;while (pNode != NULL){nodes.push(pNode);pNode = pNode->m_pNext;}while (!nodes.empty()){pNode = nodes.top();nodes.pop();cout << pNode->m_nValue << "\t";}
}

递归方式

//从尾到头打印链表，递归方式
void PrintListNode_Recursively(ListNode* pHead)
{ListNode* pNode = pHead;if (pNode != NULL){if (pNode->m_pNext != NULL){PrintListNode_Recursively(pNode->m_pNext);}}cout << pNode->m_nValue << "\t";
}

//面试题6 重建二叉树

BinaryTreeNode* Construct(int* PreOrder, int* Inorder, int length)
{if (PreOrder == NULL || Inorder == NULL || length <= 0)return NULL;elsereturn ConstructCore(PreOrder, PreOrder + length - 1, Inorder, Inorder + length - 1);
}BinaryTreeNode* ConstructCore(int* PreOrderStart, int* PreOrderEnd, int* InOrderStart, int*InOrderEnd)
{int RootValue = PreOrderStart[0];BinaryTreeNode* Root = new BinaryTreeNode();Root->m_nValue = RootValue;Root->m_pLeft = Root->m_pRight = NULL;if (PreOrderEnd == PreOrderStart){if (InOrderStart == InOrderEnd&&InOrderStart[0] == RootValue)return Root;if (InOrderStart == InOrderEnd&&InOrderStart[0] != RootValue)throw exception("Invalid Input");}//构建左右子树int* PreLeftRoot = PreOrderStart + 1;int LeftTreeLength = 0;int* InRoot = InOrderStart;while (InRoot!=InOrderEnd&&*InRoot != RootValue){InRoot++;LeftTreeLength++;}if (InRoot == InOrderEnd&&*InRoot != RootValue)throw exception("Invalid Input");if (LeftTreeLength > 0){Root->m_pLeft = ConstructCore(PreOrderStart + 1, PreOrderStart + LeftTreeLength, InOrderStart, InOrderStart + LeftTreeLength - 1);}if (LeftTreeLength < InOrderEnd - InOrderStart){Root->m_pRight = ConstructCore(PreOrderStart + LeftTreeLength + 1, PreOrderEnd, InRoot + 1, InOrderEnd);}
}

//用两个堆栈做成一个队列
template<typename T>class CQueue
{
public:CQueue();~CQueue(void);void AppendTail(const T& node);T& DeleteHead();
private:stack<T> stack1;stack<T> stack2;
};template<typename T> void CQueue::AppendTail(const T& node)
{stack1.push(node);
}template<typename T> T& CQueue::DeleteHead()
{if (stack2.empty()){if (!stack1.empty()){while (!stack1.empty()){T& node = stack1.top();stack1.pop();stack2.push(node);}}elsethrow exception("Invalid Input");}T node2 = stack2.top();stack2.pop();return node2;
}

用两个队列实现一个堆栈的方法和上面类似。只要充分利用队列先进先出和堆栈后进先出的特点即可。

template<typename T>T CStack::DeleteHead(const T& node)
{if (q1.empty()){while (!q2.empty()){T& node = q2.top();q2.pop();if (!q2.empty())q1.push(node);}}else{while (!q1.empty()){T& node = q1.top();q1.pop();if (!q1.empty())q2.push(node);}}
}

//快速排序
void swap(int &a, int &b)
{int temp;temp = a;a = b;b = temp;
}
int Partition(int data[], int length, int start, int end)
{if (data == NULL || length <= 0 || start < 0 || end >= length)throw exception("Invalid Input");int index = (start + end) / 2;int small = start - 1;swap(data[index], data[end]);for (int index = start; index < end; ++index){if (data[index] < data[end]){++small;if (small != index)swap(data[small], data[index]);}}++small;swap(data[small], data[end]);return small;
}void QuickSort(int data[], int length, int start, int end)
{if (start == end)return;int index = Partition(data, length, start, end);if (index>start)QuickSort(data, length, start, index - 1);if (index < end)QuickSort(data, length, index + 1, end);
}

转载于:https://www.cnblogs.com/chengxuyuanxiaowang/p/4242619.html