C++博客-Zero Lee的专栏-随笔分类-Data structure and algorithms

如何将一片内存链接成链表

Zero Lee — Sat, 16 Jun 2012 10:38:00 GMT

假设有一片内存，大小为m*n, m是每个单元的大小，而且>=8，共有n个这样的单元，如何将它们链接成n个节点的链表，要求不再使用任何其它内存空间。

这里给出SGI STL内存分配器的一个简单实现：
首先定义一个union数据结构：

1 union obj {
2 union obj* free_list_link;
3 char client_data[1];
4 };

这个union结构体的最大大小为4bytes （在32bits 平台上），8bytes （在64bits平台上）。

假设那片内存的地址为chunk，那么我们可以这样做：

1 obj* current_obj, *next_obj;
2 next_obj = (obj*)chunk;
3 for (int i = 0; ; i++) {
4     current_obj = next_obj;
5     next_obj = (obj*)((char*)next_obj + m);
6     if (n - 1 == i) {
7         current_obj -> free_list_link = 0;
8         break;
9     } else {
10         current_obj -> free_list_link = next_obj;
11     }
12 }
13

Zero Lee 2012-06-16 18:38 发表评论

求一个正整数的平方根程序实现

Zero Lee — Wed, 19 Oct 2011 01:37:00 GMT

求一个正整数的平方根的程序实现：
采用加法递增的方式来代替乘法与N进行比较，递增是按照等差数列的方式。

1 int square(int n)
2 {
3     int tmp = 0;
4     for (int i = 1; i < n; i++) {
5         tmp += 2*(i-1)+1;
6         if (tmp == n)
7             return i;
8         continue;
9     }
10     if (n!=0) {
11         printf("no integer sqare found!\n");
12         tmp = -1;
13     }
14     return tmp;
15 }
16

Zero Lee 2011-10-19 09:37 发表评论

一组数的全排列和组合程序实现

Zero Lee — Wed, 19 Oct 2011 01:34:00 GMT

显示一组数的全排列和组合程序：

1 void print(const std::vector<int>& s)
2 {
3     static int n = 1;
4     printf("%d:", n++);
5     printf("[");
6     for (int i = 0; i < s.size(); i++)
7         printf(" %d ", s[i]);
8     printf("]\n");
9 }
10
11 void permutation(std::vector<int>& v, int beg, int end)
12 {
13     if (beg > end) {
14         print(v);
15         return;
16     }
17     for (int i = beg; i <= end; i++) {
18         std::swap(v[i], v[beg]);
19         permutation(v, beg+1, end); // pleate note, here always beg+1, not i+1
20         std::swap(v[i], v[beg]);
21     }
22 }
23
24 void pm(std::vector<int>& v)
25 {
26     std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
27     printf("\nfull permulation are:\n");
28     permutation(v, 0, v.size()-1);
29 }
30
31 void print(const std::vector<int>& v, int beg, int end)
32 {
33     static int n = 1;
34     printf("%d:", n++);
35     printf("[");
36     std::copy(v.begin()+beg, v.begin()+end+1, std::ostream_iterator<int>(std::cout, " "));
37     printf("]\n");
38 }
39
40 void fullcombination(std::vector<int>& v)
41 {
42     printf("

full combination are:\n");
43     for (unsigned int i = 0; i < v.size(); i++) {
44         print(v, i, i);
45         for (unsigned int j = i+1; j < v.size(); j++) {
46             for (int k = 0; k < v.size()-j; k++) {
47                 std::swap(v[j+k], v[j]);
48                 print(v, i, j);
49                 std::swap(v[j+k], v[j]);
50             }
51         }
52     }
53 }
54

Zero Lee 2011-10-19 09:34 发表评论

Generating Permutations

Zero Lee — Wed, 21 Sep 2011 07:22:00 GMT

A permutation can be obtained by selecting an element in the given set and recursively permuting the remaining elements.

1 P(a1,...,aN) = aN if N = 1" />

At each stage of the permutation process, the given set of elements consists of two parts: a subset of values that already have been processed, and a subset that still needs to be processed. This logical seperation can be physically realized by exchanging, in the i’th step, the i’th value with the value being chosen at that stage. That approaches leaves the first subset in the first i locations of the outcome.

permute(i) 
   if i == N  output A[N] 
   else 
      for j = i to N do 
         swap(A[i], A[j]) 
         permute(i+1) 
         swap(A[i], A[j])

Zero Lee 2011-09-21 15:22 发表评论

快速排序C++实现

Zero Lee — Fri, 16 Sep 2011 06:15:00 GMT

2种方案的C++实现：

1 #include <vector>
  2 #include <iterator>
  3 #include <algorithm>
  4 #include <iostream>
  5 #include <cstdlib>
  6 #include <ctime>
  7 #include <cassert>
  8
  9 void printv(const std::vector<int>& v)
10 {
11     std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
12     std::cout << std::endl;
13 }
14
15 void printv(const std::vector<int>& v, int l, int h)
16 {
17     std::copy(v.begin()+l, v.begin()+h+1, std::ostream_iterator<int>(std::cout, " "));
18     std::cout << std::endl;
19 }
20
21 int exchange(int& a, int& b)
22 {
23     int tmp = a;
24     a = b;
25     b = tmp;
26 }
27
28 int partition1(std::vector<int>& v, int l, int h)
29 {
30     int i = l-1;
31     int pivot = v[h];
32     int j = l;
33     while (j < h) {
34         if (v[j] < pivot) {
35             i++;
36             exchange(v[i], v[j]);
37         }
38         j++;
39     }
40     exchange(v[i+1], v[h]);
41     return i+1;
42 }
43
44 int partition2(std::vector<int>& v, int l, int h)
45 {
46     int m = l+(h-l)/2;
47     int i = l;
48     int j = h;
49
50     int pivot = v[m];
51     while (1) {
52         while (v[i] < pivot) i++;
53         while (v[j] > pivot) j--;
54         if (!(i<j)) {
57             return j;
58         }
59         exchange(v[i], v[j]);
60         i++;j--;
61     }
62 }
63
64 void myQuickSort1(std::vector<int>& v, int l, int h)
65 {
66 /*
67   Please note, returned m is the loc of pivot,
68   in below myQuickSort1, can remove m, since left of m, all <= pivot
69   right of m, all >= pivot
70  */
71     if (l < h) {
72         int m = partition1(v, l, h);
73         myQuickSort1(v, l, m-1);
74         myQuickSort1(v, m+1, h);
75     }
76 }
77
78 void myQuickSort2(std::vector<int>& v, int l, int h)
79 {
80 /*
81  if partition2 return i, please call below
82   myQuickSort2(v, l, m-1);
83   myQuickSort2(v, m, h);
84  else if it return j, please call below
85   myQuickSort2(v, l, m);
86   myQuickSort2(v, m+1, h);
87 */
88     if (l < h) {
89         int m = partition2(v, l, h);
90         myQuickSort2(v, l, m);
91         myQuickSort2(v, m+1, h);
92     }
93 }
94
95 int main()
96 {
97
98     const int N = 100;
99     srand(time(0));
100     std::vector<int> v, vtmp;
101     for (int i = 0; i < N; i++)
102         v.push_back(int(rand()%N));
103     vtmp.insert(vtmp.end(), v.begin(), v.end());
104     std::cout << "Original data sequence is:\n";
105     std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
106     std::cout << std::endl;
107     myQuickSort1(v, 0, N-1);
108     std::cout << "After quicksort(1), the data sequence is:\n";
109     std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));
110     std::cout << std::endl;
111
112     myQuickSort2(vtmp, 0, N-1);
113     std::cout << "After quicksort(2), the data sequence is:\n";
114     std::copy(vtmp.begin(), vtmp.end(), std::ostream_iterator<int>(std::cout, " "));
115     std::cout << std::endl;
116
117     assert(v==vtmp);
118     return 0;
119 }
120

Zero Lee 2011-09-16 14:15 发表评论

堆排序算法的一个实现

Zero Lee — Fri, 25 Mar 2011 01:32:00 GMT

Pseudcode

1 function heapSort(a, count) is
2      input:  an unordered array a of length count
3
4      (first place a in max-heap order)
5      heapify(a, count)
6
7      end := count-1 //in languages with zero-based arrays the children are 2*i+1 and 2*i+2
8      while end > 0 do
9          (swap the root(maximum value) of the heap with the last element of the heap)
10          swap(a[end], a[0])
11          (put the heap back in max-heap order)
12          siftDown(a, 0, end-1)
13          (decrease the size of the heap by one so that the previous max value will
14          stay in its proper placement)
15          end := end - 1
16
17  function heapify(a, count) is
18      (start is assigned the index in a of the last parent node)
19      start := count / 2 - 1
20
21      while start ≥ 0 do
22          (sift down the node at index start to the proper place such that all nodes below
23           the start index are in heap order)
24          siftDown(a, start, count-1)
25          start := start - 1
26      (after sifting down the root all nodes/elements are in heap order)
27
28  function siftDown(a, start, end) is
29      input:  end represents the limit of how far down the heap
30                    to sift.
31      root := start
32
33      while root * 2 + 1 ≤ end do          (While the root has at least one child)
34          child := root * 2 + 1        (root*2 + 1 points to the left child)
35          swap := root        (keeps track of child to swap with)
36          (check if root is smaller than left child)
37          if a[swap] < a[child]
38              swap := child
39          (check if right child exists, and if it's bigger than what we're currently swapping with)
40          if child < end and a[swap] < a[child+1]
41              swap := child + 1
42          (check if we need to swap at all)
43          if swap != root
44              swap(a[root], a[swap])
45              root := swap          (repeat to continue sifting down the child now)
46          else
47              return
48

C++ 实现

1 // build one maximum heap
2 template <typename T>
3 void heapsort(std::vector<T>& a)
4 {
5     int sz = (int)a.size();
6     for (int i = sz/2; i >= 0; i--)
7         percDown(a, i, sz);
8     std::cout << "build heap is done.\n";
9     for (int j = sz-1; j > 0; j--) {
10         std::swap(a[0], a[j]);
11         percDown(a, 0, j);
12     }
13 }
14
15 inline int leftChild(int i)
16 {
17     return 2*i+1;
18 }
19
20 template <typename T>
21 void percDown(std::vector<T>& a, int i, int n)
22 {
23     int child;
24     T tmp;
25     for (tmp = a[i]; leftChild(i) < n; i = child) {
26         child = leftChild(i);
27         if (child != n-1 && a[child] < a[child+1])
28             child++;
29         if (tmp < a[child])
30             a[i] = a[child];
31         else
32             break;
33     }
34     a[i] = tmp;
35 }
36

Zero Lee 2011-03-25 09:32 发表评论

删除与某个字符相邻且相同的字符

Zero Lee — Tue, 22 Mar 2011 10:40:00 GMT

删除与某个字符相邻且相同的字符，如，abcddef，删除相邻的相同字符d后变为： abcdef。
要求：输入字符串,输出删除后的结果。
参考STL算法： unique/unique_copy

1 void deldupchar(char* s)
2 {
3     char* i, *j;
4     if (s && *s!='\0') {
5         i = s; j = s+1;
6         while (*j!='\0') {
7             if (*i!=*j)
8                 *++i = *j;
9             j++;
10         }
11         *++i = '\0';
12     }
13 }
14

Zero Lee 2011-03-22 18:40 发表评论

selection algorithm to select nth small elements based on partition

Zero Lee — Thu, 17 Mar 2011 12:20:00 GMT

http://en.wikipedia.org/wiki/Selection_algorithm
1. partition algorithm

1  function partition(list, left, right, pivotIndex)
2      pivotValue := list[pivotIndex]
3      swap list[pivotIndex] and list[right]  // Move pivot to end
4      storeIndex := left
5      for i from left to right-1
6          if list[i] < pivotValue
7              swap list[storeIndex] and list[i]
8              storeIndex := storeIndex + 1
9      swap list[right] and list[storeIndex]  // Move pivot to its final place
10      return storeIndex

2. selection algorithm

1 function select(list, left, right, k)
2      loop
3          select pivotIndex between left and right
4          pivotNewIndex := partition(list, left, right, pivotIndex)
5          if k = pivotNewIndex - left + 1
6              return list[pivotNewIndex]
7          else if k < pivotNewIndex - left + 1
8              right := pivotNewIndex-1
9          else
10              left := pivotNewIndex+1
11              k := k - pivotNewIndex

>> In above last statement, one bug. Should be
k := k-pivotNewIndex-left+1
left := pivotNewIndex+1

3. code

1 int partition(std::vector<int>& a, int l, int r)
2 {
3     int i = l, j = l;
4     int p = a[r];
5     while (j<r) {
6         if (a[j] < p) {
7             std::swap(a[i], a[j]);
8             i++;
9         }
10         j++;
11     }
12     std::swap(a[r], a[i]);
13     return i;
14 }
15
16 void select_kth_smallest(std::vector<int>& a, int l, int r, int k)
17 {
18     while (1) {
19         int cut = partition(a, l, r);
20 #if 0
21         std::copy(a.begin()+l, a.begin()+cut, std::ostream_iterator<int>(std::cout, " "));
22         std::cout << " <=" << a[cut] << "=> ";
23         std::copy(a.begin()+cut+1, a.begin()+r+1, std::ostream_iterator<int>(std::cout, " "));
24         std::cout << "cut("<<cut<<"),k("<<k<<"),l("<<l<<"),r("<<r<<")\n";
25 #endif
26         if (cut-l+1==k)
27             break;
28         else if (k < cut-l+1)
29             r = cut-1;
30         else {
31             k = k-cut-1+l;
32             l = cut+1;
33         }
34     }
35 }
36

Zero Lee 2011-03-17 20:20 发表评论

从尾到头输出单链表的值

Zero Lee — Tue, 15 Mar 2011 05:51:00 GMT

题目：输入一个单链表的头结点，从尾到头反过来输出每个节点的值。链表节点的定义如下：

1 struct ListNode {
2 int m_nKey;
3 ListNode* m_pNext;
4 };

理解题目的意思，只需要反转输出每个几点的值就可以了。并不需要将单链表进行反转。

1 void printSingleListReversely(ListNode* phead)
2 {
3    if (*phead!=NULL) {
4        printStringListReversely(phead->m_pNext);
5        print("%d ", phead->m_nKey);
6    }
7 }

延伸：1) 从尾到头输出字符串; 2）定义个函数求字符串的长度，函数内不能声明任何变量。

Zero Lee 2011-03-15 13:51 发表评论

腾讯面试题

Zero Lee — Fri, 11 Mar 2011 11:20:00 GMT

一个文件中有40亿个整数，每个整数为四个字节，内存为1GB，写出一个算法：求出这个文件里的整数里不包含的一个整数
下面的代码片段仅仅是一个样例。
4个字节的整数最大可表示为2^32=4294967296, 一个数一个数的读入内存，建立一个bit map，共需要4294967296个bits(也就是0.5G字节的内存，并没有超过1G内存的限制)，读入每一个数，置相应的bit为1。

1     int N = 20; // # of number
2     int M = 1000;   // number range
3     std::vector<int> a(N); // can be imported from external file number by number
4     for (int i = 0; i < N; i++)
5         a[i] = (int)rand()%M;
6     std::copy(a.begin(), a.end(), std::ostream_iterator<int>(std::cout, " "));
7     std::cout << "\n";
8     // bit map setup for existence of each number
9     unsigned int nbytes = M%8 ? (M/8+1) : (M/8);
10     std::cout << "nbytes = " << nbytes << "\n";
11
12     char* p = new char [nbytes];
13     memset(p, 0, sizeof(char)*nbytes);
14
15     for (int i = 0; i < N; i++) {
16         unsigned int index = a[i]/8;
17         unsigned int bitpos = a[i]%8;
18         char* tmp = p+index;
19         *tmp |= 1 << bitpos;
20         //std::cout << "bit pos set to 1 : " << 8*index+bitpos << "\n";
21     }
22     for (int i = nbytes-1; i >= 0; i--) {
23         printf("%02X ", (char)*(p+i)&0xFF);
24     }
25     std::cout << "\n";
26     delete [] p;
27

Zero Lee 2011-03-11 19:20 发表评论

非printf形式的十六进制和二进制打印（雅虎面试题）

Zero Lee — Fri, 11 Mar 2011 11:14:00 GMT

编程实现：把十进制数(long型)分别以二进制和十六进制形式输出，不能使用printf系列

1 template <typename T>
2 void displayHexBin(const T& v)
3 {
4     const unsigned char c2h[] = "0123456789ABCDEF";
5     const unsigned char c2b[] = "01";
6
7     unsigned char* p = (unsigned char*)&v;
8     char* buf = new char [sizeof(T)*2+1];
9     char* ptmp = buf;
10     p = p + sizeof(T)-1;
11     for (int i = 0; i < sizeof(T); i++, --p) {
12         *buf++ = c2h[*p >> 4];
13         *buf++ = c2h[*p & 0x0F];
14     }
15     *buf = '\0';
16     printf("hex format displayed as %s\n", ptmp);
17
18     delete [] ptmp;
19     p = (unsigned char*)&v; p = p + sizeof(T)-1;
20     ptmp = buf = new char [sizeof(T)*8+1];
21     for (int i = 0; i < sizeof(T); i++, --p) {
22         for (int j = 0; j < 8; j++)
23             *buf++ = c2b[(*p >> (7-j)) & 0x1];
24     }
25     *buf = '\0';
26     printf("bin format displayed as %s\n", ptmp);
27     delete [] ptmp;
28 }
29

Zero Lee 2011-03-11 19:14 发表评论

百度的面试题解答

Zero Lee — Fri, 11 Mar 2011 11:10:00 GMT

给定一个存放整数的数组，重新排列数组使得数组左边为奇数，右边为偶数。
要求：空间复杂度O(1)，时间复杂度为O（n）。

1 bool func(int n)
2 {
3     return (n&1)==0; // n%2 is more expensive
4 }
5
6 void group_oddeven(std::vector<int>& a, bool (*func)(int))
7 {
8     int i = 0, j = a.size()-1;
9     int buf = 0;
10     while (i < j) {
11         if (!func(a[i]))    // odd, move forward
12         {   i++; continue; }
13         if (func(a[j]))     // even, move backward
14         {   j--; continue; }
15
16         std::swap(a[i++], a[j--]);
17     }
18 }
19

Zero Lee 2011-03-11 19:10 发表评论

设计包含min函数的栈

Zero Lee — Fri, 26 Nov 2010 04:13:00 GMT

定义栈的数据结构，要求添加一个min的函数，能够得到栈的最下元素。
要求函数min, push, pop的时间复杂度都是O(1)

1 class stackmin {
2     int data[N];
3     int minidx[N];
4     int top;
5 public:
6     stackmin()
7         : top(-1)
8     {
9         ::memset(minidx, -1, sizeof(int)*N);
10         ::memset(data, 0, sizeof(int)*N);
11     }
12
13     bool push(int d)
14     {
15         if (top < N-1)
16             data[++top] = d;
17         else
18             return false;
19         if (top==0)
20             minidx[top] = 0;
21         else if (data[minidx[top-1]] > d)
22             minidx[top] = top;
23         else
24             minidx[top] = minidx[top-1];
25         return true;
26     }
27     bool pop(int& d)
28     {
29         if (top<0)
30             return false;
31         else
32
33             d = data[top];
34         minidx[top] = -1;
35         top--;
36         return true;
37     }
38     bool min(int& m)
39     {
40         if (top>=0)
41             m = data[minidx[top]];
42         else
43             return false;
44         return true;
45     }
46     void print()
47     {
48         for (int i = 0; i <= top; i++)
49             std::cout << data[i] << " ";
50         std::cout << "\n";
51     }
52 };
53

借助另一个内部的数组，用来存储每次push元素之后的栈最小值的索引，便可很方便的在O(1)的时间内完成以上三种操作。一种空间换时间的方法。

Zero Lee 2010-11-26 12:13 发表评论

Calcuate power n of x recursively

Zero Lee — Mon, 18 Oct 2010 09:19:00 GMT

Given x and n, calculate its power n:

1 int power(int x, int n)
2 {
3    if (n==0)
4      return 1;
5    else (n%2==0)
6      return power(x*x, n/2);
7    else
8      return x*power(x*x, n/2);
9 }
10
11

Zero Lee 2010-10-18 17:19 发表评论

Convert one binary search tree to double-linked list

Zero Lee — Mon, 18 Oct 2010 04:30:00 GMT

Give one binary search tree, and convert it to one double-linked list
Cpp code demo as below:

1 struct BSTreeNode
2 {
3     int m_value;
4     BSTreeNode* m_pLeft;
5     BSTreeNode* m_pRight;
6 };
7
8 BSTreeNode* convert(BSTreeNode* phead, bool asRight)
9 {
10     if (!phead)
11         return NULL;
12     BSTreeNode* pLeft = 0, *pRight=0;
13     if (phead->m_pLeft)
14         pLeft = convert(phead->m_pLeft, false);
15     if (pLeft) {
16         pLeft->m_pRight = phead;
17         phead->m_pLeft = pLeft;
18     }
19     if (phead->m_pRight)
20         pRight = convert(phead->m_pRight, true);
21     if (pRight) {
22         pRight->m_pLeft = phead;
23         phead->m_pRight = pRight;
24     }
25     BSTreeNode* ptmp = phead;
26     if (asRight) {
27         while (ptmp->m_pLeft) {
28             ptmp = ptmp->m_pLeft;
29         }
30     } else {
31         while (ptmp->m_pRight) {
32             ptmp = ptmp->m_pRight;
33         }
34     }
35     return ptmp;
36 }
37
38 BSTreeNode* convert2doublelist(BSTreeNode* phead)
39 {
40     return convert(phead, true);
41 }
42

Zero Lee 2010-10-18 12:30 发表评论

Calculate maximum sum of any subarray set

Zero Lee — Mon, 18 Oct 2010 04:27:00 GMT

Given one array, and calculate its maximum sum from any sequential subarray set
Cpp code demo as below:

1 int maxSubarraySum(int arr[], int length, int& beg, int& end)
2 {
3     assert(arr!=0);
4     int maxSum = 0;
5     int tmpSum = 0;
6     beg = 0; end = 0;
7     for (int i = 0; i < length; i++) {
8         tmpSum += arr[i];
9         if (tmpSum < 0) {   // discard it
10             tmpSum = 0;
11             beg = end = i+1;
12         }
13         if (tmpSum > maxSum) {
14             maxSum = tmpSum;
15             end = i+1;
16         }
17     }
18     if (maxSum ==0 ) {      // if all numbers are negative, return max value
19         maxSum = arr[0];
20         for (int i = 1; i < length; i++)
21             if (maxSum < arr[i]) {
22                 maxSum = arr[i];
23                 beg = i; end = i+1;
24             }
25     }
26     return maxSum;
27 }
28

Zero Lee 2010-10-18 12:27 发表评论

One SRC demo to reverse one single-linked list

Zero Lee — Mon, 18 Oct 2010 04:23:00 GMT

Below is one src demo to reverse one single-linked list:

1 struct listNode {
2    int value;
3    listNode* next;
4 };
5
6 listNode* reverseList(listNode* phead)
7 {
8     listNode* pcur = phead;
9     listNode* pprev = 0, *pnext = 0;
10     while (pcur) {
11   pnext = pcur->next;
12   pcur->next = pprev;
13
14       pprev = pcur;
15       pcur = pnext;
16    }
17    return pcur;
18 }

Zero Lee 2010-10-18 12:23 发表评论