Cracking the Coding Interview 150题（一）

1、数组与字符串

---

1.1 实现一个算法，确定一个字符串的所有字符是否全都不同。假设不允许使用额外的数据结构，又该如何处理？

1.2 用C或C++实现void reverse(char* str)函数，即反转一个null结尾的字符串。

1.3 给定两个字符串，请编写程序，确定其中一个字符串的字符重新排列后，能否变成另一个字符串。

1.4 编写一个方法，将字符串中的空格全部替换为“%20”。假设该字符串尾部有足够的空间存放新增字符，并且知道字符串的“真实”长度。示例：输入Mr John Smith，输出Mr%20John%20Smith。

1.5 利用字符重复出现的次数，编写一个方法，实现基本的字符串压缩功能。比如，字符串aabcccccaaa会变为a2b1c5a3。若“压缩”后的字符串没有变短，则返回原先的字符串。

1.6 给定一幅由 N x N 矩阵表示的图像，其中每个像素的大小为 4 字节，编写一个方法，将图像旋转90度。不占用额外内存空间能否做到？

1.7 编写一个算法，若 M x N 矩阵中某个元素为0，则将其所在的行与列清零。

1.8 假定有一个方法isSubstring，可检查一个单词是否为其他字符串的子串。给定两个字符串 s1 和 s2，请编写代码检查 s2 是否为 s1 旋转而成，要求只能调用一次isSubstring。（比如，waterbottle是erbottlewat旋转后的字符串。）

2、链表

---

2.1 编写代码，移除未排序链表中的重复结点。如果不得使用临时缓冲区，又该怎么解决？

2.2 实现一个算法，找出单向链表中倒数第 k 个结点。

2.3 实现一个算法，删除单向链表中间的某个结点，假定你只能访问该结点。示例：

• 输入：单向链表a->b->c->d->e中的结点c
• 结果：不返回任何数据，但该链表变为a->b->d->e。

2.4 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前。

2.5 给定两个用链表表示的整数，每个结点包含一个数位。这些数位是反向存放的，也就是个位排在链表首部。编写函数对这两个整数求和，并用链表形式返回结果。示例：

• 输入：（7->1->6）+（5->9->2），即 617+295
• 输出：2->1->9，即 912

假设这些数位是正向存放的，请再做一遍。示例：

• 输入：（6->1->7）+（2->9->5），即 617+295
• 输出：9->1->2，即 912

2.6 给定一个有环链表，实现一个算法返回环路的开头结点。有环链表的定义：在链表中某个结点的 next 元素指向在它前面出现过的结点，则表明该链表存在环路。示例：

• 输入：A->B->C->D->E->C（C结点出现了两次）
• 输出：C

2.7 编写一个函数，检查链表是否为回文。

参考答案（C++）

---

1.1 如果允许使用数据结构，我首先想到的是map，下标操作map['key']在 key 存在时执行搜索操作，否则执行插入操作。示例代码如下：

bool func(char A[], int len)
{
    map<char, int> amap;
    for(int i=0; i<len; ++i)
    {
        amap[A[i]] += 1;
    }

    map<char, int>::iterator beg = amap.begin();
    for(;beg!=amap.end(); ++beg)
    {
        if(beg->second > 1)
            return false;
    }
    return true;
}

如果不允许使用额外的数据结构，该如何处理呢？假定字符集为 ASCII，那么我们可以创建一个标记数组，索引 i 对应的 bool 值指示该字符串是否含有字母表第 i 个字符。若这个字符第二次出现，则立即返回 false。

bool func(char A[], int len)   // 假定字符集为 ASCII
{
    if(len > 256)
        return false;

    bool char_set[256] = {false};
    for(int i=0; i<len; ++i)
    {
        if(char_set[A[i]]) // 字符已经出现过
            return false;
        char_set[A[i]] = true;
    }

    return true;
}

1.2 根据函数的原型void reverse(char* str)，我们并不知道字符串的长度，所以需要先求出长度再进行反转：

void reverse(char* str)
{
    char* tmp = str;
    int len = 0;
    while(*tmp++ != '\0')  // 求出字符串的长度
        ++len;

    int low = 0;
    int high = len - 1;
    while(low < high)    // 反转
    {
        char c = str[low];
        str[low] = str[high];
        str[high] = c;
        ++low;
        --high;
    }
}

1.3 由题意可知，这是一个变位词的问题，可以看我的另一篇文章《变位词问题》。通常的做法是把两个字符串按字母表顺序排序，比较排序后的字符串是否相等：

bool myfunction(char i, char j)
{
    return i > j;
}

bool Compare(string s1, string s2)
{
    if(s1.length() != s2.length())
        return false;

    // 泛型算法 sort() 采用的是快速排序算法
    sort(s1.begin(), s1.end(), myfunction);
    sort(s2.begin(), s2.end(), myfunction);
    if(!s1.compare(s2))  // 相等返回0
        return true;
    else
        return false;
}

另外一种方法就是：检查两个字符串的各字符数是否相同。（假定字符集为ASCII）我们只需创建一个大小 256 的整型数组，遍历第一个字符串，给每个字符计数；遍历第二个字符串，递减对应字符的数量。最后判断数组元素是否全部为0。

1.4 本题的思路就是进行两次扫描。第一次扫描记录字符串中有多少空格，从而计算最终字符串的长度；第二次扫描从后往前移动字符并插入20%。代码如下：

void replaceSpace(char *str, int len)
{
    int spaceNum = 0;
    for(int i=0; i<len; ++i)
    {
        if(str[i] == ' ')
            ++spaceNum;
    }

    int newLen = len + spaceNum*2;
    for(int i=len-1; i>=0; --i)
    {
        if(str[i] != ' ')
        {
            str[newLen - 1] = str[i];
            newLen = newLen - 1;
        }
        else
        {
            str[newLen - 1] = '0';
            str[newLen - 2] = '2';
            str[newLen - 3] = '%';
            newLen = newLen - 3;
        }
    }
}

1.5 本题思路很简单：遍历字符串，将字符和对应的重复次数拷贝到新字符串。

// int转string
string int2string(int n)
{
    stringstream ss;
    string str;
    ss << n;
    ss >> str;
    return str;
}

string compress(string str)
{
    string tmp;
    char c = str[0];
    int count = 1;
    for(int i=1; i<str.length(); ++i)
    {
        if(str[i] == c)
            ++count;
        else
        {
            tmp = tmp + c + int2string(count);
            c = str[i];
            count = 1;
        }
    }
    tmp = tmp + c + int2string(count);

    return str.length()>tmp.length() ? tmp:str;
}

1.6 归纳题意，简言之就是：对N阶方阵进行原地转置。（思路就是对每一层执行环状旋转，将上边移到右边、右边移到下边、下边移到左边、左边移到上边）

void rotate(int **mtx, int n)
{
    for(int layer=0; layer < n/2; ++layer)
    {
        int first = layer;
        int last = n-1-layer;
        for(int i=first; i<last; ++i)
        {
            int offset = i - first;
            // 暂存上边：top = mtx[first][i]
            int top = *((int*)mtx+first*n+i);

            // 左到上：mtx[first][i] = mtx[last-offset][first]
            *((int*)mtx+first*n+i) = *((int*)mtx+(last-offset)*n+first);

            // 下到左：mtx[last-offset][first] = mtx[last][last-offset]
            *((int*)mtx+(last-offset)*n+first) = *((int*)mtx+last*n+(last-offset));

            // 右到下：mtx[last][last-offset] = mtx[i][last]
            *((int*)mtx+last*n+(last-offset)) = *((int*)mtx+i*n+last);

            // 上到右：mtx[i][last] = top
            *((int*)mtx+i*n+last) = top;
        }
    }
}

这里要注意二维数组作参数传递的问题，另外调用的时候像这样rotate((int**)A, 4)。这个算法的时间复杂度为O(n^2)，已是最优的做法。

1.7 这个问题貌似很简单，直接遍历嘛！只要发现为零的元素，就将其所在的行与列清零。不过这个方法有个陷阱：清零以后会导致连锁效应，最后整个矩阵都变成 0。我们的做法是：遍历两遍，第一遍记录要清零的行与列，第二遍再执行清零操作。

void setZero(int **mtx, int m, int n)
{
    bool *row = new bool[m](); // 默认初始化为false
    bool *col = new bool[n]();

    for(int i=0; i<m; ++i)
        for(int j=0; j<n; ++j)
        {
            if(*((int*)mtx+i*n+j) == 0)
            {
                row[i] = true;
                col[j] = true;
            }
        }

    for(int i=0; i<m; ++i)
        for(int j=0; j<n; ++j)
        {
            if(row[i] || col[j])
            {
                *((int*)mtx+i*n+j) = 0;
            }
        }

    delete [] row;
    delete [] col;
}

1.8 如果x = wat，y = erbottle，则s1 = xy，s2 = yx。不论x和y之间的分割点在何处，我们会发现yx肯定是xyxy的子串。即，s2总是s1s1的子串。

bool isRotation(string s1, string s2)
{
    if(s1.length() == s2.length() && s1.length()>0)
    {
        return isSubstring(s1+s1, s2);
    }
    return false;
}

---

在解决链表问题时，首先我们得学会如何创建链表，下面是单链表创建和打印的示例代码：

typedef struct node
{
    node* next;
    int data;
} *LinkList;

// 根据数组创建单链表：尾插法
LinkList createList(int A[], int len)
{
    int i = 0;
    node *head = (node*)malloc(sizeof(node));
    node *s, *tail = head;
    while(i<len)
    {
        s = (node*)malloc(sizeof(node));
        s->data = A[i++];
        tail->next = s;
        tail = s;
    }
    tail->next = NULL;
    return head;  /*头结点不保存数据*/
}

// 打印单链表
void printList(LinkList L)
{
    node *p = L->next;
    while(p!=NULL)
    {
        cout << p->data;
        p = p->next;

        if(p!=NULL)
            cout << "->";
    }
    cout << endl;
}

2.1 要想移除链表中的重复结点，我们只需在遍历的过程中，将每个未重复结点加入一个缓冲区。若发现有结点在缓冲区已经存在（即重复），则将该结点从链表中移除。只需遍历一次即可。

void deleteDups(LinkList L)
{
    set<int> buffer;   // 这里使用set容器
    node *p = L->next;
    node *pre = L;
    while(p!=NULL)
    {
        int data = p->data;
        if(buffer.find(data) == buffer.end())
        {
            buffer.insert(data);
            pre = p;
            p = p->next;
        }
        else  /* 重复 */
        {
            pre->next = p->next;
            node* q = p;  // 记录删除的结点
            p = p->next;
            free(q);  // 释放
        }
    }
}

如果不借助额外的缓冲区，那么就只能两两比较以判断是否重复，时间复杂度为O(n^2)。需要使用两个指针来迭代：

void deleteDups(LinkList L)
{
    if(L == NULL) return;

    node* current = L->next;
    while(current!=NULL)
    {
        node* runner = current;
        while(runner->next!=NULL)
        {
            if(runner->next->data == current->data)
            {
                node* p = runner->next;
                runner->next = runner->next->next;
                free(p);
            }
            else
            {
                runner = runner->next;
            }
        }
        current = current->next;
    }
}

2.2 本题有多种解法。

• 解法一：有人可能首先会想到：这太简单了，先遍历一次链表获取长度 length，那么倒数第 k 个结点就是第 (length - k)个结点。但是，你觉得这会是面试官想要的答案吗？？

• 解法二：递归。先通过递归到达链表的末尾，然后从后往前进行计数，每次递归调用返回时，将计数器加1。当计数器等于 k 时，访问的就是链表倒数第 k 个元素。（注意计数器 i 需要传引用）

node* kthToLast(node* head, int k, int &i)
{
    if(head == NULL)
        return NULL;

    node* p = kthToLast(head->next, k, i);
    i = i + 1;
    if(i == k)
    {
        return head;
    }
    return p;
}

• 解法三：迭代法。相比于递归，迭代法通常不太直观但效率更高。思路就是：用两个指针 p1 和 p2 指向链表中两个距离为k的结点，然后以相同速度移动这两个指针，当其中一个指针指向链表的尾结点时，另一个指针指向的就是倒数第k个结点。（“快行指针”技巧）

node* kthToLast(LinkList L, int k)    // 时间复杂度O(n)，空间复杂度O(1)
{
    if(k<=0)
        return NULL;

    // 两个指针
    node* p1 = L->next;
    node* p2 = L->next;

    // p2向前移动k个结点
    for(int i=0; i<k-1; ++i)
    {
        if(p2 == NULL)  /*错误检查*/
            return NULL;
        p2 = p2->next;
    }

    if(p2 == NULL) return NULL;

    // 移动p1与p2
    while(p2->next!=NULL)
    {
        p1 = p1->next;
        p2 = p2->next;
    }
    return p1;
}

2.3 本题中，你访问不到链表的首结点，只能访问待删除结点及之后的结点。所以我们的做法是：直接将后继结点的数据复制到当前结点，然后删除这个后继结点。

bool deleteNode(node* c)
{
    if(c==NULL || c->next==NULL) // 尾结点无法删除
        return false;

    node* next = c->next;
    c->data = next->data;
    c->next = next->next;
    free(next);

    return true;
}

2.4 链表不同于数组，在用现有元素创建新的链表时，我们不必移动和交换元素，只是改变元素的 next 指针的指向。所以本题的思路也很简单：遍历链表，将小于 x 的元素连接成一个链表，将大于等于 x 的元素连接成一个链表，最后合并两个链表即可。

LinkList partition(LinkList L, int x)
{
    node* biggerHead = NULL;
    node* biggerTail = NULL;
    node* smallerHead = NULL;
    node* smallerTail = NULL;

    node* p = L->next;
    while(p!=NULL)
    {
        node* next = p->next;
        p->next = NULL;
        if(p->data < x)
        {   /*将比x小的结点插入smaller链表的尾部*/
            if(smallerHead == NULL)
            {
                smallerHead = p;
                smallerTail = smallerHead;
            }
            else
            {
                smallerTail->next = p;
                smallerTail = p;
            }
        }
        else
        {   /*将比x大的结点插入bigger链表的尾部*/
            if(biggerHead == NULL)
            {
                biggerHead = p;
                biggerTail = biggerHead;
            }
            else
            {
                biggerTail->next = p;
                biggerTail = p;
            }
        }
        p = next;
    }

    /*遍历结束，合并两个链表*/
    if(smallerHead == NULL)
    {
        L->next = biggerHead;
        return L;
    }
    smallerTail->next = biggerHead;
    L->next = smallerHead;
    return L;
}

2.5 本题的思路是逐个结点对应相加，然后判断是否进位。我们使用递归来模拟这个加法过程。

LinkList add(LinkList L1, LinkList L2, int carry)
{
    /*两个链表全部为空且进位为0，则函数返回*/
    if(L1==NULL && L2==NULL && carry==0)
        return NULL;

    node* result = (node*)malloc(sizeof(node));

    int value = carry;
    if(L1!=NULL)
        value+=L1->data;
    if(L2!=NULL)
        value+=L2->data;

    result->data = value%10;  /*取个位*/

    node* more = add(L1==NULL?NULL:L1->next,
                    L2==NULL?NULL:L2->next,
                    value>=10?1:0);

    result->next = more;
    return result;
}

注意，这里add之后返回的链表没有“头指针”。

2.6 这个问题是由经典面试题——检查链表是否存在回路——演变而来。

如上图所示，如果链表中存在回路，那么我们遍历时会陷入死循环。那么，我们如何检测链表是否存在环 以及 寻找环的入口点呢？答案是“快慢指针”。

① 设置两个指针（fast、slow），初始值都指向头，slow每次前进一步，fast每次前进二步。如果链表存在环，则fast必定先进入环，而slow后进入环，两个指针必定相遇。这是检测。

② 在fast和slow第一次相遇的时候，假定slow走了n步，环路的入口是在p步，

c为fast和slow相交点距离环路入口的距离。那么，slow走的路径： p+c ＝ n；

fast走的路径： p+c+k*L = 2*n（L为环路的周长，k是整数），即n = k*L

显然，如果从p+c点开始，slow再走n步的话，还可以回到p+c这个点。

同时，fast从头开始走，步长为1，经过n步，也会达到p+c这点。

显然，在这个过程中fast和slow只有前p步骤走的路径不同。所以当p1和p2再次重合的时候，必然是在链表的环路入口点上。

③ 综上所述，可得出如下算法：

• 创建两个指针：fast和slow

• slow每走一步，fast就走两步

• 两者碰在一起时，将slow重新指向链表头，fast保持不变

• 以相同速度移动slow和fast，一次一步，然后返回新的碰撞处。

node* findLoopEntrance(LinkList L)
{
    node* slow = L->next;
    node* fast = L->next;

    while(fast!=NULL && fast->next!=NULL)
    {
        slow = slow->next;
        fast = fast->next->next;
        if(fast == slow)  /*碰撞*/
            break;
    }

    if(fast==NULL || fast->next==NULL)
        return NULL;  /*没有环路*/

    slow = L->next;   /*重新指向链表头*/
    while(slow!=fast)
    {
        slow = slow->next;
        fast = fast->next;
    }
    return fast;
}

2.7 所谓“回文”指正向看和反向看是一样的。在链表中可以定义为 0->1->2->1->0。

• 解法一：根据定义，先将整个链表反转，然后比较反转链表和原始链表。若两者相同，则该链表为回文。（只需比较链表的前半部分）

• 解法二：迭代法。先进行迭代，将链表的前半部分入栈，再继续进行迭代，与后半部分进行比较。每次迭代时，比较当前结点和栈顶元素，若完成迭代时比较结果完全相同，则该链表为回文。（在链表长度未知的情况下，可以使用“快慢指针”将前半部分入栈）

bool isPalindrome(LinkList L)
{
    node* fast = L->next;
    node* slow = L->next;

    stack<int> s;

    /**将链表的前半部分入栈**/
    while(fast!=NULL && fast->next!=NULL)
    {
        s.push(slow->data);
        slow = slow->next;
        fast = fast->next->next;
    }

    /**链表有奇数个元素，跳过中间元素**/
    if(fast!=NULL)
        slow = slow->next;

    /**比较**/
    while(slow!=NULL)
    {
        int top = s.top();
        s.pop();
        if(top!=slow->data)
            return false;
        slow = slow->next;
    }

    return true;
}

个人站点：http://songlee24.github.com