C++博客-coding everyday-随笔分类-Algorithm

统计数组中未出现和多次出现的值

everyday — Thu, 29 Aug 2013 02:24:00 GMT

#面试题#给定数组A，大小为n，数组元素为1到n的数字，不过有的数字出现了多次，有的数字没有出现。请给出算法和程序，统计哪些数字没有出现，哪些数字出现了多少次。能够在O(n)的时间复杂度，O(1)的空间复杂度要求下完成么？

想了好久，都没能想出来算法，我觉得是不是自己走进死胡同了，决定再看一遍题目，这一遍果然让我发现，原来自己真的理解错了题目的意思，我一开始以为要输出多次出现的数字对应的数字，所以一直都绕不过来弯。

所以有时候面试过程中，重新确认题目还是有必要的，有时候面试紧张会误解题目意思，当自己没有思路的时候，可以尝试确认题意，以来可以缓解一下自己的心情，再者可能面试官会跟你有更多的互动，增加好感。

确定了题意，基于之前的思考，我的算法是这样的遍历一遍数组，用-2,-1,0来表示没有出现，出现一次，出现多次，如果当前节点大于0，目标节点为它对应的值，当前置为-2，若小于0，加一但不要超过0。算法需要一个递归函数（用来递归处理目标节点一直大于0的情况，即未处理过的）和一个遍历的函数。最终0即为多次出现，-1出现1次的，-2没有出现。因为有2个前提这个算法才有效：1～n；只要出现多次和没出现的数字，不需要次数。

1 #include <iostream>
2 #include <array>
3 using namespace std;
4
5 template<int N>
6 class array_stat {
7 public:
8     array_stat(const array<int, N>& arr) : m_arr(arr) {
9     }
10
11     void operator()() {
12         for (int i=1; i<=N; i++) {
13             process(i);
14         }
15
16         for (int i=0; i<N; i++) {
17             if (m_arr[i] == 0)
18                 cout << i+1 << " exists more than once" << endl;
19             else if (m_arr[i] == -2)
20                 cout << i+1 << " doesnt exist" << endl;
21         }
22     }
23 private:
24     array<int, N> m_arr;
25
26     void process(int i) {
27         if (m_arr[i-1] > 0) {
28             int cur = m_arr[i-1];
29             m_arr[i-1] = -2;
30             process(cur);
31         }
32         else {
33             m_arr[i-1]++;
34             if (m_arr[i-1] > 0)
35                 m_arr[i-1] = 0;
36         }
37     }
38 };
39
40 int main() {
41     array<int, 10> arr = {2, 1, 4, 3, 5, 6, 5, 6, 5, 6};
42     array_stat<10> stat(arr);
43     stat();
44     return 0;
45 }

源代码

everyday 2013-08-29 10:24 发表评论

第n杯水

everyday — Thu, 01 Aug 2013 05:43:00 GMT

摘要: 一座金字塔，从上到下，第一层有一个杯子、第二层有两个杯子，依次类推。每个杯子的容量为C升，从塔顶倒下L升水，当1号杯子满了之后，会等量溢出到2号和3号杯子。当2号和3号满了，2号溢出到4号和5号，3号溢出到5号和6号，注意5号接受来自两个杯子的水。依次类推。给定C和L，请问，第n杯里有多少水。阅读全文

everyday 2013-08-01 13:43 发表评论

面试题：熟悉的陌生人

everyday — Fri, 19 Jul 2013 01:52:00 GMT

摘要: #面试题#Facebook用户都是双向的好友，a是b的好友，那么b一定是a的。给定一个用户列表，有些用户是好友，有些不是，请判断，这些用户是否可以划分为两组，每组内的用户，互相都不是好友。如果能，请给出这个划分。比如用户：{1, 2, 3} 好友关系：1-2， 2-3 划分：{1,3} {2}。

题目乍一看，感觉像是图连通的问题。细细品了下，貌似不是滴。阅读全文

everyday 2013-07-19 09:52 发表评论

算法题：一个不能少

everyday — Thu, 18 Jul 2013 02:14:00 GMT

摘要: #面试编程题#一个不能少：有k个有序的数组，请找到一个最小的数字范围。使得这k个有序数组中，每个数组都至少有一个数字在该范围中。例如：1:{ 4, 10, 15, 24, 26 }；2: { 0, 9, 12, 20 }；3: { 5, 18, 22, 30 }。所得最小范围为[20,24]，其中，20在2中，22在3中，24在1中。阅读全文

everyday 2013-07-18 10:14 发表评论

括号匹配问题

everyday — Sat, 13 Jul 2013 09:20:00 GMT

这个问题很简单，大学学数据结构的时候，讲堆栈一章的时候作为其中一个例子来说的。但是如果面试中被问到这个题，我想用堆栈来做应该不能被接受吧，理由是空间和时间的代价都挺高的。

有没有稍微好点的算法呢？介绍个时间O(n), 空间O(1)的算法。

既然我们只是要找出括号有没有匹配就行了，那我们用一种方式记下左括号和右括号的次数不就可以了，例如left_count, right_count。它们的差为0不就好了？只要不为0，肯定就不匹配了，对吧？更进一步，为啥非要用2个变量呢，一个就够了嘛。遇到左括号++，遇到右括号--，最后为0即匹配。

1 bool is_brackets_match(char *const input) {
2     if (input != nullptr) {
3         char *p = input;
4         int count = 0;
5
6         while (*p != '\0') {
7             if (*p == '(')
8                 ++count;
9             else if (*p == ')')
10                 --count;
11
12             p++;
13         }
14
15         if (count == 0)
16             return true;
17     }
18     return false;
19 }

everyday 2013-07-13 17:20 发表评论

Magic Index

everyday — Fri, 12 Jul 2013 06:25:00 GMT

#面试编程题#给定一个数组A，其中有一个位置被称为Magic Index，含义是：如果i是Magic Index，则A[i] = i。假设A中的元素递增有序、且不重复，请给出方法，找到这个Magic Index。当A中允许有重复的元素，该怎么办呢？

第一个，不重复，很简单，用二分查找就OK了。对吧

1 int find_magic_index2(int *list, int count) {
2     int low = 0, high = count - 1;
3     while (high > low) {
4         int idx = (high + low) / 2;
5         if (idx == list[idx])
6             return idx;
7         else if (list[idx] > idx) {
8             high = idx - 1;
9         }
10         else
11             low = idx + 1;
12     }
13
14     return -1;
15 }

第二个，可重复的，该怎么办?从头到尾走一边，总归是可以的嘛。:)。我的想法是，如果a[i]等于i的话，找到了；如果大于i的话，让i=a[i]，不然i++继续找。这样最差的情况才是O(n)
至于为什么可以让i=a[i]，原因由于数列是递增的，所以数组元素在{i, a[i]}的区间中，肯定不可能存在magic index。这样看上去是不是跳跃着前进啊。:)

1 int find_magic_index (int *list, int count) {
2     int i=0;
3     while (i<count) {
4         if (list[i] == i)
5             return i;
6         else if (list[i] > i)
7             i = list[i];
8         else
9             i++;
10     }
11     return -1;
12 }

everyday 2013-07-12 14:25 发表评论

单链表的快速排序

everyday — Fri, 12 Jul 2013 05:41:00 GMT

单链表的快速排序
单链表的快速排序跟数组的排序原理上一致，有一个分区（区分）的函数在一个区间中针对某个标杆值进行区分，比它大的放它后面，比它小的放它前面，并返回它的地址，好对它前面的以及它后面的递归。

单链表的快速排序跟数组有个明显的区别，就是指示起始和终止的元素，在一轮之后它们在链表中的位子会发生改变，所以需要返回一个新的起始的位置（终止的位置）
我的算法中总是拿后一个的节点作为终止位置，所以它在链表中的位子其实是不改变的，所以我只修改了起始位置指向新的起始位置即可。

我的算法是，用2个链表，一个放比它大的一个放比它小的，最后接起来，它的位置就是mid，而其实位置就是当初起始的前一个节点在新链表中的next。有点拗口，就是说a->start->...->nullptr，这一轮传进来的是start，那么经过这轮的分区之后，start的位置肯定改变了，对吧？但是a->next的地址没有改变，即&(a->next)，因为start之前的都会原封不动的放在那里。我觉得用指针的地址来处理是这里的关键之处吧。

这是一轮partition之前和之后的图示，之后就对于(begin, mid)和（mid->next, end)进行快速排序即可。

1 // Problem: sort a singly link list by Quick Sort
2 node *partition(list &l, node *&begin, node *end = nullptr) {
3     // if end is the next node, that means it's only one node to sort
4     if (begin == nullptr || end == begin->next) {
5         return nullptr;
6     }
7
8     list small_list, big_list;
9     node *current = l.root;
10     node *pivot = begin;
11     node **pbegin;          // points to the address of begin
12     node **s_current = &small_list.root, **b_current = &big_list.root;
13
14     // move previous nodes before 'begin' to small list
15     while (current != begin) {
16         *s_current = current;
17         s_current = &(*s_current)->next;
18         current = current->next;
19     }
20
21     // pbegin presents the location(address) of begin item, e.g. if (a->next == begin) then pbegin = &a->next;
22     pbegin = s_current;
23
24     while (begin != end) {
25         if (begin->data < pivot->data) {
26             *s_current = begin;
27             s_current = &(*s_current)->next;
28         }
29         else {
30             *b_current = begin;
31             b_current = &(*b_current)->next;
32         }
33
34         begin = begin->next;
35     }
36
37     // pass begin back to quick_sort for next sort action
38     begin = *pbegin;
39
40     *b_current= end;
41     *s_current = big_list.root;
42     l = small_list;
43     l.print();
44
45     // current pivot would be the end node for smaller set sorting
46     return big_list.root;
47 }
48
49 void quick_sort(list &l, node *begin, node *end = nullptr) {
50     if (begin == end) {
51         return;
52     }
53     // mid represents the pivot node which is the next node of the end of the small list
54     node *mid = partition(l, begin, end);
55
56     if (mid != nullptr){
57         quick_sort(l, begin, mid);
58     }
59
60     if (mid != nullptr &&
61         mid->next != nullptr) {
62         quick_sort(l, mid->next, end);
63     }
64 }

代码

everyday 2013-07-12 13:41 发表评论

蓄水池抽样

everyday — Wed, 03 Jul 2013 01:29:00 GMT

yeah. 首先要恭喜下自己，昨天的算法蒙对了，请看@陈利人的帖子。【鼓掌】【鼓掌】:)

经典面试题：蓄水池抽样

要求从N个元素中随机的抽取k个元素，其中N无法确定。

这种应用的场景一般是数据流的情况下，由于数据只能被读取一次，而且数据量很大，并不能全部保存，因此数据量N是无法在抽样开始时确定的；但又要保持随机性，于是有了这个问题。所以搜索网站有时候会问这样的问题。

这里的核心问题就是“随机”，怎么才能是随机的抽取元素呢？我们设想，买彩票的时候，由于所有彩票的中奖概率都是一样的，所以我们才是“随机的”买彩票。那么要使抽取数据也随机，必须使每一个数据被抽样出来的概率都一样。

哎呀妈呀，这题目一天比一天难啊。目测搞不定啊。

在班车上简单分析了下，N的值要到最后才知道，从N个里面抽k个元素，要是概率知识没有都还给老师的话，每个元素被抽中的概率是C_N^k，对不？唔，既然在N知道之前，就要一样概率的抽取k个元素，那我能不能猜想最后的算法其实是跟N无关的呢？不管怎么样先挖个坑再说，目测这个坑不一定能填上。:D

everyday 2013-07-03 09:29 发表评论

找出最流行搜索词

everyday — Tue, 02 Jul 2013 13:10:00 GMT

本题目出自@陈利人

问题：
#Google面试题#给你一天的Google搜索日志，你怎么设计算法找出是否有一个搜索词，它出现的频率占所有搜索的一半以上？如果肯定有一个搜索词占大多数，你能怎么提高你的算法找到它？再假定搜索日志就是内存中的一个数组，能否有O(1)空间，O(n)时间的算法？

刚看到这个题目的时间吓坏了，好难啊，无从下手啊，为自己的之上捉急啊。。下班的班车上开始想这个问题，开始分析，其实这个搜索日志就是一个搜索词的集合嘛，甭管它有多大，总可以分成若干堆吧。既然这个搜索词超过一半，那么在这若干堆中分别找出来最流行的词中，也应该占一半吧。（这个应该没有理解错吧。）

这个时候我想可以把问题转换成一个整数数组，其中有个整数出现的次数超过一半，找出这个整数就OK了吧。要找出这个数组中出现次数超一半的值，本身这个算法应该很简单，但是O(1)空间和O(n)的时间复杂度，还是有点伤脑筋的。。:(，内存又不贵，为啥O(1)啊。。

因为那个数字出现的次数超过一半，我们可以想象一下，把那个数字标成1，其它的都是-1，把所有的数字加起来肯定大于0，对吧？因为超过一半嘛。。这个时候灵光乍现，用一个标杆来标志潜在的那个搜索词，一个整数count表示它出现的次数（准确的说不是它的次数，后面会解释），遍历整个数组
1) 如果当前的跟标杆一样，count++
2) 如果不相等，--count，若此时count为0，则把当前值置为标杆，count为1
重复1), 2)即可，最后那个标杆即为最流行搜索词。

代码简单的我不能相信，以至于我觉得我肯定理解错误题目的意思了，不管怎么样上下代码：

1 // Get the most popular searching keyword in Google. :)
2 template
3 T get_most_popular_keyword(const T *list, int size) {
4     T result = list[0];
5     int count = 0;
6
7     for (int i=0; i 8         if (list[i] == result)
9             count++;
10         else {
11             if (--count == 0) {
12                 count = 1;
13                 result = list[i];
14             }
15         }
16     }
17
18     return result;
19 }

everyday 2013-07-02 21:10 发表评论

[失败的挑战]: 求两个单链表的和

everyday — Tue, 02 Jul 2013 01:51:00 GMT

本文描述的是我自己的一个失败的挑战经历。

题目

两个单链表（singly linked list），每一个节点里面一个0-9的数字，输入就相当于两个大数了。然后返回这两个数的和（一个新list）。这两个输入的list 长度相等。要求是：1. 不用递归。2. 要求算法在最好的情况下，只遍历两个list一次，最差的情况下两遍。

我的算法是： 2次遍历是肯定能的，第一次相加并以倒序存，第二次进位并倒序。一次/两次的算法，用2个指针，一个指钱一个，另一个指向再前一个，另一个flag标志是否走第二轮。只有前前位有进位flag置true跑第二次。

为啥当时会有这样的想法呢？因为所有数字都是0～9，所以我假设了第一轮的相加和进位能把大部分该进位的都进了，所以如果存在需要第二轮的话，找出那个条件就好了。当时就沿着这个思路走了。当然大部分情况下这个算法是可行的，但是这里有个很明显的漏洞，当时被胜利冲昏头脑的我怎么会想的到呢？就是一开始没有出现进位，后来连续进位的情况，如@赵小罡这位朋友设计的用例 1000001+9999999。一并感谢其他指出错误的网友。

如果有人想怀着鄙视的心态看下我错误的代码，请点击“源码"，不过放在心里就好了，不要打击我脆弱的心灵哦。:)

另外有个高手做了一个算法，总是只要一次就能搞定的。@hawstein详情见“求两个单链表的和” 尼害的不得了。他的网站上还有不少好东西呢。对于他的算法，我有个改进的建议就是，以他的算法完全没有必要单独考虑第一个节点的情况，在遍历结束后，判断下第一个节点是否大于9就OK了，如果大于9，最前面插入一个节点。

everyday 2013-07-02 09:51 发表评论