《剑指Offer》题十一~题二十
十一、旋转数组的最小数字
题目：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组{3, 4, 5, 1, 2}为{1, 2, 3, 4, 5}的一个旋转，该数组的最小值为1。
测试用例：
- 功能测试，如输入的数组是升序排序数组的一个旋转。
- 边界值测试，如输入的数组是一个升序排序的数组，或只包含一个数字的数组。
- 特殊输入测试，如输入nullptr指针。
分析：旋转之后的数组实际上可以划分为两个排序的子数组，而且前面子数组的元素值更大，元素值最小的元素恰好是两个子数组的分界点。
拙劣二分查找法：
int find_min(int *pArr, int length)
{
if(pArr == nullptr || length <= 0)
return -1;
if(length == 1)
return pArr[0];
int left = 0;
int right = length - 1;
int mid = (right - left) / 2;
if(pArr[mid] < pArr[mid+1]) {
if(pArr[mid] > pArr[mid-1]) {
return find_min(pArr, mid + 1);
return find_min(pArr + mid, right - mid + 1);
}
else
return pArr[mid];
}
if(pArr[mid] > pArr[mid+1]) {
return pArr[mid+1];
}
}
分析：没有考虑数组中有重复数字的情况，且该二叉查找法的实现代码存在纰漏。
完整解法：
int Min(int* numbers, int length)
{
if(numbers == nullptr || length <= 0)
throw new std::exception("Invalid parameters");
int index1 = 0;
int index2 = length - 1;
int indexMid = index1;
while(numbers[index1] >= numbers[index2])
{
// 如果index1和index2指向相邻的两个数，
// 则index1指向第一个递增子数组的最后一个数字，
// index2指向第二个子数组的第一个数字，也就是数组中的最小数字
if(index2 - index1 == 1)
{
indexMid = index2;
break;
}
// 如果下标为index1、index2和indexMid指向的三个数字相等，
// 则只能顺序查找
indexMid = (index1 + index2) / 2;
if(numbers[index1] == numbers[index2] && numbers[indexMid] == numbers[index1])
return MinInOrder(numbers, index1, index2);
// 缩小查找范围
if(numbers[indexMid] >= numbers[index1])
index1 = indexMid;
else if(numbers[indexMid] <= numbers[index2])
index2 = indexMid;
}
return numbers[indexMid];
}
int MinInOrder(int* numbers, int index1, int index2)
{
int result = numbers[index1];
for(int i = index1 + 1; i <= index2; ++i)
{
if(result > numbers[i])
result = numbers[i];
}
return result;
}
考点：
- 对二分查找的理解。
- 应聘者思维的全面性，如排序数组本身是数组旋转的一个特例。
十二、矩阵中的路径
十三、机器人的运动范围
十四、剪绳子
十五、二进制中1的个数
题目：请实现一个函数，输入一个整数，输出该数二进制表示中1的个数。例如，把9表示成二进制是1001，有2位是1。
测试用例：
- 正数，包括边界值1、0x7FFFFFFF。
- 负数，包括边界值0x80000000、0xFFFFFFFF。
- 0。
循环的次数等于整数二进制的位数：
int number_of_1(int n)
{
int count = 0;
unsigned int flag = 1;
while(flag) {
if(n & flag)
count++;
flag = flag << 1; // 左移32次后，flag变为0
}
return count;
}
分析：首先把n和1做与运算，判断n的最低位是不是为1。接着把1左移一位得到2，再和n做与运算，就能判断n的次低位是不是1……这样反复左移，每次都能判断n的其中一位是不是1。
循环的次数等于整数二进制中1的位数：
int number_of_1(int n)
{
int count = 0;
while(n) {
++count;
n = (n - 1) & n;
}
return count;
}
十六、数值的整数次方
题目：实现函数double Power(double base, int exponent)，求base的exponent次方。不得使用库函数，同时不需要考虑大数问题。
分析：此题要求实现一个具有pow函数的功能的函数。要求实现特定库函数的功能是一类常见的面试题，特别是处理数值和字符串的函数。
考虑全面但不够高效的解法：
bool invalidInput = false;
bool equal_double(double x1, double x2)
{
if ((x1 - x2 < 0.0000001) && (x1 - x2 > -0.0000001))
return true;
return false;
}
double Power(double base, int exponent)
{
if(equal_double(base, 0.0) && exponent <= 0) {
invalidInput = true;
return 0.0;
}
double ans = 1.0;
bool expIsNegative = false;
if(exponent < 0) {
expIsNegative = true;
exponent *= -1;
}
for(int i = 1; i <= exponent; ++i) {
ans *= base;
}
if(expIsNegative) {
ans = 1.0 / ans;
}
return ans;
}
分析：在上段代码中，我们既考虑到底/指数为0的情况，又考虑到正确处理错误输入的情况。但该函数要做exponent-1次乘法，效率较低。
十七、打印从1到最大的n位数
题目：输入数字n，按顺序打印出从1到最大的n位十进制数。比如输入3，则打印出1、2、3一直到最大的3位数999。
简单思考后的解法：
void print_1_to_max(int n)
{
int maxNum = 1;
for(int i = 1; i <= n; ++i)
maxNum *= 10;
maxNum = maxNum - 1;
for (int i = 1; i <= maxNum; ++i)
printf("%d\t", i);
}
分析：本题没有规定n的范围，故当输入的n很大时，整型（int）或者长整型（long long）都将溢出，即我们要考虑大数问题。
在字符串上模拟数字加法的解法：
/* 用字符串来解决大数问题 */
void print_1_to_max(int n)
{
if(n <= 0) return;
char *pNum = new char[n + 1];
memset(pNum, '0', n);
pNum[n] = '\0';
/* 开始依次处理每一个数 */
while(!increment(pNum)) // 当没有增加到999...9时
{
print_pNum(pNum);
}
delete []pNum;
}
/* 在表示数字的字符串pNum上增加1 */
/* 在字符串表达的数字上模拟加法 */
bool increment(char *pNum)
{
bool isOverflow = false; // 用于判断最高位是否超出9
int takeOver = 0; // 用于进位
int len = strlen(pNum);
for(int i = len - 1; i >= 0; --i) {
int sum = pNum[i] - '0' + takeOver;
if(i == len -1) sum++;
if(sum >= 10) {
if(i == 0) {
isOverflow = true;
}
else {
takeOver = 1;
sum -= 10;
pNum[i] = sum + '0';
}
}
else {
pNum[i] = sum + '0';
break;
}
}
return isOverflow;
}
/* 把字符串表达的数字打印出来 */
void print_pNum(char *pNum)
{
int len = strlen(pNum);
bool isFirstNonZero = false; // 更整齐地输出不足n位的数
for(int i = 0; i < len; ++i) {
if(pNum[i] > '0' && isFirstNonZero == false)
isFirstNonZero = true;
if(isFirstNonZero == true)
printf("%c", pNum[i]);
}
printf("\t");
}
考点：
- 解决大数问题的能力。
十八、删除链表的节点
题目一：在O(1)时间内删除链表节点。给定单向链表的头指针和一个节点指针，定义一个函数在O(1)时间内删除该节点。
分析：在单向链表中删除一个节点，常规的解法是根据所给的头节点，顺序遍历查找要删除的节点，并在链表中删除该节点。然而，这种思路的时间复杂度为O(n)。
正确解法：
void DeleteNode(ListNode **pListHead, ListNode *pToBeDeleted)
{
if(*pListHead == nullptr || pToBeDeleted == nullptr)
return;
// 链表中有多个节点，要删除的节点不是尾节点
if(pToBeDeleted->next != nullptr) {
ListNode *pNode = pToBeDeleted->next;
/* 巧妙地避免了查找前一个节点所需的开销 */
pToBeDeleted->value = pNode->value;
pToBeDeleted->next = pNode->next;
delete pNode;
pNode = nullptr;
}
// 链表只有一个节点，要删除的节点是尾节点（也是头节点）
else if(pToBeDeleted == *pListHead) {
delete pToBeDeleted;
pToBeDeleted = nullptr;
*pListHead = nullptr;
}
// 链表中有多个节点，要删除的节点是尾节点
else {
ListNode *pTemp = *pListHead;
while(pTemp->next != pToBeDeleted) {
pTemp = pTemp->next; // 只有这一种情况需要遍历整个链表
}
pTemp->next = nullptr;
delete pToBeDeleted;
pToBeDeleted = nullptr;
}
}
小结：在知晓指向要删除的节点的指针时，就不一定需要得到被删除的节点的前一个节点。正如上段代码所示，我们把下一个节点的内容复制到需要删除的节点上覆盖原有的内容，再把下一个节点删除，这就相当于把当前需要删除的节点删除了。
题目二：删除链表中重复的节点。在一个排序的链表中，如何删除重复的节点？
解法：
void DeleteDuplication(ListNode **pListHead)
{
if(pListHead == nullptr || *pListHead == nullptr) return;
ListNode *pPreNode = nullptr;
ListNode *pCurrent = *pListHead;
while(pCurrent != nullptr) {
ListNode *pNext = pCurrent->next;
bool isNeedDeleted = false;
if(pNext != nullptr && pNext->value == pCurrent->value)
isNeedDeleted = true;
if(!isNeedDeleted) {
pPreNode = pCurrent;
pCurrent = pCurrent->next;
}
else {
int value = pCurrent->value;
ListNode *pToBeDeleted = pCurrent;
while(pToBeDeleted != nullptr && pToBeDeleted->value == value) {
pNext = pToBeDeleted->next;
delete pToBeDeleted;
pToBeDeleted = nullptr;
pToBeDeleted = pNext;
}
if (pPreNode == nullptr) {
*pListHead = pNext;
}
else {
pPreNode->next = pNext;
}
pCurrent = pNext;
}
}
}
分析：此题关键在于分析问题的全面性，例如头节点可能被删除，故传入的参数为指向指向头节点的指针的指针。
十九、正则表达式匹配
二十、表示数值的字符串
题目：请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100"、"5e2"、"-123"、"3.1416"及"-1E-16"都表示数值，但"12e"、"1a3.14"、"1.2.3"、"+-5"及"12e+5.4"都不是。
分析：表示数值的字符串遵循一定的模式，如A[.[B]][e|EC]或者.B[e|EC]，其中A为数值的整数部分，B紧跟着小数点为数值的小数部分，C紧跟着'e'或者'E'为数值的指数部分。要注意的是，在小数里可能没有数值的整数部分，因此A部分不是必需的。
解法：
bool isNumeric(const char *str)
{
if(str == nullptr) return false;
bool numeric = scanInteger(&str);
if(*str == '.') {
++str;
numeric = numeric || scanUnsignedInteger(&str); // 小数点可以没有整数部分，如.123,123.等
}
if(*str == 'e' || *str == 'E') {
++str;
numeric = numeric && scanInteger(&str);
}
return numeric && *str == '\0';
}
bool scanInteger(const char **str)
{
if(**str == '+' || **str == '-') (*str)++;
return scanUnsignedInteger(str);
}
bool scanUnsignedInteger(const char **str)
{
const char *before = *str;
while(**str != '\0' && **str >= '0' && **str <= '9')
(*str)++;
return *str > before;
}
分析：判断一个字符串是否符合上述模式时，首先尽可能多地扫描0~9的数位，如模式中的A、B、C部分。
