各大公司筆試面試題之數據結構與算法

1. 把二元查找樹轉變成排序的雙向鏈表

//基本思想：假設根的左右兩棵子樹都已經轉爲鏈表，則只需將根指向左孩子的鏈指向左鏈表的最後一個節點
//將根指向右孩子的鏈指向右鏈表的第一個節點
#include <iostream>
using namespace std;

struct node
{
    int value;
    node *left;
    node *right;
};

void treeToList(node *root)
{
    if(!root)
        return;
    treeToList(root->left);
    treeToList(root->right);
    node *cur;
    if(root->left)
    {
        cur = root->left;
        while(cur->right)
        {
            cur = cur->right;
        }
        root->left = cur;
        cur->right = root;
    }
    if(root->right)
    {
        cur = root->right;
        while(cur->left)
        {
            cur = cur->left;
        }
        root->right = cur;
        cur->left = root;
    }
}

node * treeToListInterface(node *root)
{
    treeToList(root);
    node *cur = root;
    if(cur)
    {
        while(cur->left)
            cur = cur->left;
    }
    return cur;
}

node * build_tree()
{
    int a;
    cin >> a;
    if(a == 0)
    {
        return NULL;
    }
    node *root = new node();
    root->value = a;
    root->left = build_tree();
    root->right = build_tree();
    return root;
}

void displayList(node *head)
{
    node *cur = head;
    while(cur)
    {
        cout  << cur->value << " ";
        cur = cur->right;
    }
    cout << endl;
}

int main()
{
    node *root = build_tree();
    root = treeToListInterface(root);
    displayList(root);
    return 0;
}

2. 設計包含 min 函數的棧。
定義棧的數據結構，要求添加一個 min 函數，能夠得到棧的最小元素。

要求函數 min 、 push 以及 pop 的時間複雜度都是 O(1) 。

//基本思想：增加一個輔助棧，輔助棧的棧頂元素既是當前最小元素的下標。
//每次出棧時，同時對輔助棧也執行pop操作。
#include <iostream>
using namespace std;
const int N = 100;
class Stack
{
private:
    int a[N];
    int top;
    int b[N];
    int btop;
public:
    Stack():top(-1),btop(-1){}
    void push(int e){
        a[++top] = e;
        if(btop == -1)
        {
            b[++btop] = 0;
        }else
        {
            b[btop + 1] = e < a[b[btop]] ? top: b[btop];
            btop++;
        }
    }
    void pop()
    {
        --top;
        --btop;
    }
    int min()
    {
        return a[b[btop]];
    }
};

int main()
{
    Stack test;
    test.push(1);
    cout << test.min() << endl;
    test.push(2);
    cout << test.min() << endl;
    test.push(4);
    cout << test.min() << endl;
    test.push(5);
    cout << test.min() << endl;
}

3. 求子數組的最大和
題目：
輸入一個整形數組，數組裏有正數也有負數。
數組中連續的一個或多個整數組成一個子數組，每個子數組都有一個和。
求所有子數組的和的最大值。要求時間複雜度爲 O(n) 。
例如輸入的數組爲 1, -2, 3, 10, -4, 7, 2, -5 ，和最大的子數組爲 3, 10, -4, 7, 2 ，

//基本思想：dp
//從後往前思考，從前往後寫代碼。
//t[i]表示包括a[i]在內的最大子數組之和
//在處理大小爲i的數組時，先假設大小爲i-1的數組已經處理好
//則t[i] = t[i - 1] + a[i] > a[i] ? t[i - 1] + a[i] : a[i];
#include <iostream>
using namespace std;

const int N =100;
int MaxSumOfSubArray(int *a, int size)
{
    int t[N];
    t[0] = a[0];
    for(int i = 1; i < size; i++)
    {
        t[i] = t[i - 1] + a[i] > a[i] ? t[i - 1] + a[i] : a[i];
    }
    int max = t[0];
    for(int i = 1; i < size; i++)
    {
        max = max > t[i] ? max : t[i];
    }
    return max;
}

int main()
{
    int a[8] = { 1, -2, 3, 10, -4, 7, 2, -5 };
    cout << MaxSumOfSubArray(a, 8);

}

4. 在二元樹中找出和爲某一值的所有路徑
題目：輸入一個整數和一棵二元樹。
從樹的根結點開始往下訪問一直到葉結點所經過的所有結點形成一條路徑。
打印出和與輸入整數相等的所有路徑。
例如輸入整數 22 和如下二元樹
10
/ \
5 12
/ \
4 7

則打印出兩條路徑： 10, 12 和 10, 5, 7 。
二元樹節點的數據結構定義爲：
struct BinaryTreeNode // a node in the binary tree
{
int m_nValue; // value of node
BinaryTreeNode *m_pLeft; // left child of node
BinaryTreeNode *m_pRight; // right child of node

};

//基本思想：函數的接口、數據結構設計好了，算法也就呼之欲出了。
//需要隨着回溯而改變的變量應該作爲遞歸函數的形參，可以考慮增加輔助函數
#include <iostream>
using namespace std;
const int N = 100;
struct BinaryTreeNode // a node in the binary tree
{
    int m_nValue; // value of node
    BinaryTreeNode *m_pLeft; // left child of node
    BinaryTreeNode *m_pRight; // right child of node
};
int path[N];
int cur = 0;

void findPathRecursively(BinaryTreeNode *root, int value ,int cur)
{
    if(!root)
        return ;
    if(!root->m_pLeft && !root->m_pLeft)
    {
        if(root->m_nValue == value)
        {
            path[cur++] = value;
            for(int i = 0; i < cur; i++)
                cout << path[i] << " ";
            cout << endl;
        }
    }
    else
    {
        path[cur++] = root->m_nValue;
        if(root->m_pLeft)
        {

            findPathRecursively(root->m_pLeft, value - root->m_nValue, cur);
        }
        if(root->m_pRight)
        {

            findPathRecursively(root->m_pRight, value - root->m_nValue, cur);
        }
    }
}

//這樣設置，path[],cur不能跟着遞歸改變。
//所以必須使用一個輔助函數
void findPath(BinaryTreeNode *root, int value)
{
    findPathRecursively(root,value,cur);
}
BinaryTreeNode * build_tree()
{
    int a;
    cin >> a;
    if(a == 0)
    {
        return NULL;
    }
    BinaryTreeNode *root = new BinaryTreeNode();
    root->m_nValue = a;
    root->m_pLeft = build_tree();
    root->m_pRight = build_tree();
    return root;
}

int main()
{
    BinaryTreeNode *tree = build_tree();
    findPath(tree, 10);

}

5. 查找最小的 k 個元素
題目：輸入 n 個整數，輸出其中最小的 k 個。
例如輸入 1 ， 2 ， 3 ， 4 ， 5 ， 6 ， 7 和 8 這 8 個數字，則最小的 4 個數字爲 1 ， 2 ， 3 和 4 。

//基本思想：先快排
//有更好的方法，以後有時間再寫


#include <iostream>
#include <ctime>
using namespace std;
const int N = 10000;

int partition(int *a, int b, int e)
{
    int i = b - 1;

    for(int j = b; j < e; j++)
    {
        if(a[j] < a[e])
        {
            i++;
            int tem = a[i];
            a[i] = a[j];
            a[j] = tem;
        }
    }

    int tem = a[i + 1];
    a[i + 1] = a[e];
    a[e] = tem;
    return i + 1;

}

void qsort(int *a, int b, int e)
{
    if(b < e)
    {
        int q = partition(a,b,e);
        qsort(a, b, q-1);
        qsort(a, q+1, e);
    }
}

void fun(int *a, int size, int k)
{
    qsort(a, 0, size - 1);
    for(int i = 0; i < k; i++)
        cout << a[i] << " ";
    cout << endl;
}
int main()
{
    int a[] = {3,4,8,2,1};
    fun(a, 5, 2);
}

第 6 題
轉換字符串格式爲：原來字符串裏的字符+該字符連續出現的個數。

#include <iostream>
#include <ctime>
#include <cassert>
using namespace std;
const int N = 10000;
void convertStringFormat(char *str)
{
    for(int i = 0, len = strlen(str); i < len; i++)
    {
        int count = 1;
        cout << str[i];
        while(str[i] == str[i + 1])
        {
            count ++;
            i++;
        }
        cout << count;
    }
}
int main()
{
    convertStringFormat("1233422222");

}

第 7 題
微軟亞院之編程判斷倆個鏈表是否相交
給出倆個單向鏈表的頭指針，比如 h1 ， h2 ，判斷這倆個鏈表是否相交。
爲了簡化問題，我們假設倆個鏈表均不帶環。

//基本思想：若兩鏈表相交，則它們最終合併爲一條鏈表

#include <iostream>
#include <ctime>
using namespace std;

struct node
{
    int value;
    node *next;
};

void displayList(node *head)
{
    node *cur = head;
    while(cur)
    {
        cout  << cur->value << " ";
        cur = cur->next;
    }
    cout << endl;
}

bool isCross(node *h1, node *h2)
{
    node *cur1 = h1, *cur2 = h2;
    if(!h1 || !h2)
        return false;
    while(cur1->next)
        cur1 = cur1->next;
    while(cur2->next)
        cur2 = cur2->next;
    return cur1 == cur2;
}
node * make_link()
{
    srand(time(NULL));
    node *head = new node();
    node *cur = head;
    for(int i= 0; i < 10; i++)
    {
        cur->value = rand() % 10;
        cur->next = new node();
        cur = cur->next;
    }
    return head;
}

int main()
{
    node *h1 = make_link();;
    node *h2 = new node();
    h2->value = 1;
    node *tem = h2->next = new node();
    tem->value = 2;
    /*tem->next = h1->next->next->next;*/
    tem->next = NULL;


    cout << isCross(h1, h2);
    return 0;
}

第8題：

問題擴展：
1. 如果鏈表可能有環列 ?
2. 如果需要求出倆個鏈表相交的第一個節點列 ?

//擴展2
//基本思想：若兩鏈表相交，則它們最終合併爲一條鏈表
//設兩鏈表的長度分別爲l1,l2，使指向長鏈表的指針先走|l1-l2|，
//然後兩鏈表指針再一起走，它們將到時到達相交節點

#include <iostream>
#include <ctime>
using namespace std;

struct node
{
    int value;
    node *next;
};

void displayList(node *head)
{
    node *cur = head;
    while(cur)
    {
        cout  << cur->value << " ";
        cur = cur->next;
    }
    cout << endl;
}


node *firstCrossNode(node *h1, node *h2)
{
    node *cur1 = h1, *cur2 = h2;

    if(!h1 || !h2)
        return NULL;
    int len1 = 1, len2 = 1;
    while(cur1->next)
    {
        cur1 = cur1->next;
        len1++;
    }
    while(cur2->next)
    {
        cur2 = cur2->next;
        len2++;
    }
    if(cur1 != cur2)
        return NULL;

    cur1 = h1;
    cur2 = h2;
    if(len1 > len2)
    {
        for(int i = 0; i < len1 - len2; i++)
        {
            cur1 = cur1->next;
        }
    }
    else
    {
        for(int i = 0; i < len2 - len1; i++)
        {
            cur2 = cur2->next;
        }
    }
    while(cur1 != cur2)
    {
        cur1 = cur1->next;
        cur2 = cur2->next;
    }
    return cur1;
}
node * make_link()
{
    srand(time(NULL));
    node *head = new node();
    node *cur = head;
    for(int i= 0; i < 10; i++)
    {
        cur->value = rand() % 10;
        cur->next = new node();
        cur = cur->next;
    }
    return head;
}

int main()
{
    node *h1 = make_link();;
    node *h2 = new node();
    h2->value = 1;
    node *tem = h2->next = new node();
    tem->value = 2;
    tem->next = h1->next->next->next;
    /*tem->next = NULL;*/


    cout << firstCrossNode(h1, h2)->value;
    return 0;
}

第9題

將一句話裏的單詞進行倒置，標點符號不倒換。比如“i come from shantou.” -> "santou. from com i"

//基本思想：先整句逆轉，再部分逆轉。

#include <iostream>
#include <ctime>
#include <cassert>
using namespace std;
const int N = 10000;
void reverse(char *str, int b, int e)
{
    int i = b, j = e;
    while(i < j)
    {
        char tem = str[i];
        str[i] = str[j];
        str[j] = tem;
        i++;
        j--;
    }
}
void reverseWordsOfSentence(char *str)
{
    reverse(str, 0, strlen(str) - 1);
    for(int i = 0, len = strlen(str); i < len; )
    {
        int b = i;
        while(str[i++] != ' ' && str[i++] != '\0')
            ;
        reverse(str, b, i - 2);
    }
}

int main()
{
    char str[] = "I come from shantou.";
    reverseWordsOfSentence(str);
    cout << str << endl;
}

第10題

實現strstr()函數

不想做。

第 11 題

求二叉樹中節點的最大距離 ...
如果我們把二叉樹看成一個圖，父子節點之間的連線看成是雙向的，
我們姑且定義 " 距離 " 爲兩節點之間邊的個數。
寫一個程序，
求一棵二叉樹中相距最遠的兩個節點之間的距離。

//總結來自《微軟編程之美》：
//  對於遞歸問題的分析，筆者有一些小小的體會：
//1. 先弄清楚遞歸的順序。在遞歸的實現中，往往需要假設後續的調用已經完成，在此
//基礎之上，才實現遞歸的邏輯。在該題中，我們就是假設已經把後面的長度計算出
//來了，然後繼續考慮後面的邏輯；
//2. 分析清楚遞歸體的邏輯，然後寫出來。比如在上面的問題中，遞歸體的邏輯就是如
//何計算兩邊最長的距離；
//3. 考慮清楚遞歸退出的邊界條件。也就說，哪些地方應該寫return。
//注意到以上 3 點，在面對遞歸問題的時候，我們將總是有章可循。
#include<iostream>
using namespace std;
struct Node
{
    Node *left;
    Node *right;
    int nMaxLeft;
    int nMaxRight;
    //char chValue;
};

int nMaxLen = 0;

int maxNode(Node *tree)
{
    return tree->nMaxLeft > tree->nMaxRight ?
        tree->nMaxLeft : tree->nMaxRight;
}

void find(Node *tree)
{
    if(tree->left)
    {
        find(tree->left);
    }else
    {
        tree->nMaxLeft = 0;
    }
    if(tree->right)
    {
        find(tree->right);
    }else
    {
        tree->nMaxRight = 0;
    }
    tree->nMaxLeft = maxNode(tree->left) + 1;
    tree->nMaxRight = maxNode(tree->right) + 1;
    nMaxLen = nMaxLen > tree->nMaxLeft + tree->nMaxRight ? nMaxLen : tree->nMaxLeft + tree->nMaxRight;

}

第 13 題：

題目：輸入一個單向鏈表，輸出該鏈表中倒數第 k 個結點。鏈表的倒數第 0 個結點爲鏈表的尾指針。

已經做過。

第 14 題：
題目：輸入一個已經按升序排序過的數組和一個數字，
在數組中查找兩個數，使得它們的和正好是輸入的那個數字。
要求時間複雜度是 O(n) 。如果有多對數字的和等於輸入的數字，輸出任意一對即可。
例如輸入數組 1 、 2 、 4 、 7 、 11 、 15 和數字 15 。由於 4+11=15 ，因此輸出 4 和 11 。

已經做過。

第 15 題：
題目：輸入一顆二元查找樹，將該樹轉換爲它的鏡像，
即在轉換後的二元查找樹中，左子樹的結點都大於右子樹的結點。
用遞歸和循環兩種方法完成樹的鏡像轉換。

例如輸入
8
/ \
6 10

/\ /\
5 7 9 11
輸出：
8
/ \
10 6
/\ /\
11 9 7 5

//基本思想：假設根的左右兩棵子樹都已經鏡像轉換好了，則只需改變根的左右鏈的指向互換就可以了
#include <iostream>
using namespace std;

struct node
{
    int value;
    node *left;
    node *right;
};

void display(node *root)
{
    if(!root)
        return ;
    display(root->left);
    cout << root->value << " ";
    display(root->right);
}

node * build_tree()
{
    int a;
    cin >> a;
    if(a == 0)
    {
        return NULL;
    }
    node *root = new node();
    root->value = a;
    root->left = build_tree();
    root->right = build_tree();
    return root;
}

void treeImage(node *root)
{
    if(!root)
        return;
    treeImage(root->left);
    treeImage(root->right);
    node *tem = root->left;
    root->left = root->right;
    root->right = tem;
}

int main()
{
    node *root = build_tree();
    treeImage(root);
    display(root);
    return 0;
}

第 16 題：
題目（微軟）：
輸入一顆二元樹，從上往下按層打印樹的每個結點，同一層中按照從左往右的順序打印。
例如輸入
7
8
/ \
6 10
/ \ / \
5 7 9 11

輸出 8 6 10 5 7 9 11 。

//基本思想：BFS
#include <iostream>
#include <ctime>
#include <queue>
using namespace std;

struct node
{
    int value;
    node *left;
    node *right;

};

node * build_tree()
{
    int a;
    cin >> a;
    if(a == 0)
    {
        return NULL;
    }
    node *root = new node();
    root->value = a;
    root->left = build_tree();
    root->right = build_tree();
    return root;
}
void print(node *root)
{
    queue<node *> toPrint;
    if(root)
    {
        toPrint.push(root);
        while(!toPrint.empty())
        {
            node *tem = toPrint.front();
            toPrint.pop();
            cout << tem->value <<  " ";
            if(tem->left)
            {
                toPrint.push(tem->left);
            }
            if(tem->right)
            {
                toPrint.push(tem->right);
            }
        }
    }
}

int main()
{
    node *root = build_tree();
    print(root);
    return 0;
}

第 17 題：
題目：在一個字符串中找到第一個只出現一次的字符。如輸入 abaccdeff ，則輸出 b 。

分析：這道題是 2006 年 google 的一道筆試題。

//注：此題解法參與了July的解法
//基本思想：涉及到出現次數的可以考慮一下用hash表
#include <iostream>
using namespace std;

char findFirstSingle(char *str)
{
    int a[255];
    memset(str,0,sizeof(a));
    char *p = str;
    while(*p != '\0')
    {
        a[*p]++;
        p++;
    }
    p = str;
    while(*p != '\0')
    {
        if(a[*p] == 1);
        return *p;
    }
    return '\0';
}

第 18 題：
題目： n 個數字（ 0,1, … ,n-1 ）形成一個圓圈，從數字 0 開始，
每次從這個圓圈中刪除第 m 個數字（第一個爲當前數字本身，第二個爲當前數字的下一個數
字）。
當一個數字刪除後，從被刪除數字的下一個繼續刪除第 m 個數字。
求出在這個圓圈中剩下的最後一個數字。

//基本思想：用循環表模擬
//網上有比較牛的算法，但有點難理解
#include <iostream>
#include <ctime>
#include <queue>
using namespace std;

struct node
{
    int value;
    node *next;

};

node* theLastGuy(int n, int m)
{
    if(n == 0)
        return NULL;
    node *head = new node();
    head->value = 0;
    node *cur = head;
    for(int i= 1; i < n; i++)
    {
        cur->next = new node();
        cur = cur->next;
        cur->value = i;
    }
    cur->next = head;
    cur = head;
    int s;
    while(cur->next)
    {
        s = m - 1;
        while(s--)
        {
            cur = cur->next;
        }
        node *tem = cur->next;
        cur->next = cur->next->next;
        tem->next = NULL;
        delete tem;

    }
}

int main()
{
    cout << "input n and m" << endl;
    int n, m;
    cin >> n >> m;
    theLastGuy(n, m);
    return 0;
}

第 20 題：
題目：輸入一個表示整數的字符串，把該字符串轉換成整數並輸出。
例如輸入字符串 "345" ，則輸出整數 345 。

//基本思想：‘3’- '0' = 3
#include <iostream>
using namespace std;

void convert(char *a)
{
    for(int i = 0; i < strlen(a); i++)
    {
        cout << a[i] - '0';
    }
}
int main()
{
    char *a = "345";
    convert(a);
    return 0;
}

第 21 題
2010 年中興面試題
編程求解：
輸入兩個整數 n 和 m ，從數列 1 ， 2 ， 3.......n 中隨意取幾個數
使其和等於 m , 要求將其中所有的可能組合列出來 .

//基本思想：組合數學，用母函數解即可。
//母函數：將離散的數列變成對應連續的冪數，冪指數爲對應的數列項的值
//母函數的G（x）=  (1+x+x^2+x^3+x^4+x^5+....)*(1+x^2+x^4+x^6+x^8+x^10+....)*

(1+x^3+x^6+x^9+x^12....).....
//其中第一項表示的1表示第一個數列取一次，x表示取兩次，...其它的數列也一樣。
//實現時，用數組下標表示冪指數，對應的值表示該冪數的係數，然後對多項式展開就可以了。
//只要計算到下標爲m的數組值就可以了，注意循環變量每次的增量。
#include <iostream>
#include <ctime>
using namespace std;
const int N = 10000;
int c1[N], c2[N];
int combination(int n, int m)
{
    int len = 0;
    for(int i = 1; i <= n ; i++)
        len += i;
    if(m > len)
        return 0;
    for(int i = 0; i <= m; i ++)
    {
        c1[i] = c2[i] = 0;
    }
    for(int i = 0; i <= 1; i++)
    {
        c1[i] = 1;
    }
    for(int i = 1; i < n ; i++)
        for(int j = 0; j <= m; j++)
            for(int k = 0;k <= i + 1 && k + j <= m; k += i+1)
            {
                c2[j + k] += c1[j];
            }
    for(int i = 0; i <= m; i++)
    {
        c1[i] = c2[i];
        c2[i] = 0;
    }
    return c1[m];
}
int main()
{
    int n , m;
    cin >> n >> m;
    cout << combination(n,m);
}

第 25 題：
寫一個函數 , 它的原形是 int continumax(char *outputstr,char *intputstr)
功能：
在字符串中找出連續最長的數字串，並把這個串的長度返回，
並把這個最長數字串付給其中一個函數參數 outputstr 所指內存。
例如： "abcd12345ed125ss123456789" 的首地址傳給 intputstr 後，函數將返回 9 ，

outputstr 所指的值爲 123456789

//基本思想：dp
#include <iostream>
#include <ctime>
using namespace std;
const int N = 10000;
int a[N];
int maxsub(char *str)
{
    if(!str)
        return 0;
    memset(a, 0, sizeof(a));
    if(str[0] >= '0' && str[0] <= '9')
        a[0] = 1;
    else
        a[0] = 0;
    int len = strlen(str);
    for(int i = 1; i < len; i++)
    {
        a[i] = str[i] >= 'a' && str[i] <= 'z' ? 0 : a[i - 1] + 1;
    }
    int max = 0;
    for(int i = 0; i < len; i++)
    {
        max = max > a[i] ? max : a[i];
    }
    return max;
}

int main()
{
    char *str = "ab12ab1234a";
    cout << maxsub(str);
}

26. 左旋轉字符串
題目：
定義字符串的左旋轉操作：把字符串前面的若干個字符移動到字符串的尾部。
如把字符串 abcdef 左旋轉 2 位得到字符串 cdefab 。請實現字符串左旋轉的函數。

要求時間對長度爲 n 的字符串操作的複雜度爲 O(n) ，輔助內存爲 O(1) 。

//基本思想：ad-hoc
#include <iostream>
#include <ctime>
using namespace std;
const int N = 10000;

void reverse(char *str, int b, int e)
{
    int i = b, j = e;
    while(i < j)
    {
        char tem = str[i];
        str[i] = str[j];
        str[j] = tem;
        i++;
        j--;
    }
}
void shift(char *str, int n)
{
    reverse(str, 0, strlen(str) - 1);
    reverse(str, 0, strlen(str) - 1 - n);
    reverse(str, strlen(str) - n, strlen(str) - 1);
}

int main()
{
    char str[] = "abcde";
    shift(str, 2);
    cout << str << endl;
}

27. 跳臺階問題
題目：一個臺階總共有 n 級，如果一次可以跳 1 級，也可以跳 2 級。
求總共有多少總跳法，並分析算法的時間複雜度。
這道題最近經常出現，包括 MicroStrategy 等比較重視算法的公司
都曾先後選用過個這道題作爲面試題或者筆試題。

//基本思想：dp。
//設a[i]爲第i階的跳法總數。從第i-1階和第i-2階可以跳到第i階
//所以a[i] = a[i - 2] + a[i - 1];
#include <iostream>
#include <ctime>
using namespace std;
const int N = 10000;

int jump(int n)
{
    int a[N];
    a[1] = 1;
    a[2] = 2;
    for(int i = 3; i <= n; i++)
    {
        a[i] = a[i - 2] + a[i - 1];
    }
    return a[n];
}

int main()
{
    int n;
    while(cin >> n)
    {
        cout << jump(n) << endl;
    }
    return 0;
}

28. 整數的二進制表示中 1 的個數
題目：輸入一個整數，求該整數的二進制表達中有多少個 1 。
例如輸入 10 ，由於其二進制表示爲 1010 ，有兩個 1 ，因此輸出 2 。
分析：
這是一道很基本的考查位運算的面試題。
包括微軟在內的很多公司都曾採用過這道題。

//基本思想：xxxxxx10000 & (xxxxxx10000-1) = xxxxxx00000
//參考了july的方法。

#include <iostream>
#include <ctime>
using namespace std;
const int N = 10000;

int binary(int n)
{
    int count = 0;
    while(n)
    {
        n = n & (n - 1);
        count++;
    }
    return count;
}

int main()
{
    cout << binary(10) << endl;
}

29. 棧的 push 、 pop 序列
題目：輸入兩個整數序列。其中一個序列表示棧的 push 順序，
判斷另一個序列有沒有可能是對應的 pop 順序。
爲了簡單起見，我們假設 push 序列的任意兩個整數都是不相等的。
比如輸入的 push 序列是 1 、 2 、 3 、 4 、 5 ，那麼 4 、 5 、 3 、 2 、 1 就有可能是一個 pop 系列。
因爲可以有如下的 push 和 pop 序列：
push 1 ， push 2 ， push 3 ， push 4 ， pop ， push 5 ， pop ， pop ， pop ， pop ，
這樣得到的 pop 序列就是 4 、 5 、 3 、 2 、 1 。
但序列 4 、 3 、 5 、 1 、 2 就不可能是 push 序列 1 、 2 、 3 、 4 、 5 的 pop 序列。

//基本思想：ad-hoc
//模擬

#include <iostream>
#include <ctime>
using namespace std;
const int N = 10000;

int stack[N];
int top = -1;

bool fun(int *push, int *pop, int n)
{
    int i = 0, j = 0;
    for(int i= 0; i < n; i++)
    {
        if(push[i] == pop[j])
            j++;
        else
            stack[++top] = push[i];
    }
    while(top >= 0)
    {
        if(stack[top--] != pop[j++])
            return false;
    }
    return true;
}
int main()
{
    int push[] = {1,2,3,4,5};
    int pop[] = {4,3,5,1,2};
    cout << fun(push, pop, 5);
}

43. 遞歸和非遞歸倆種方法實現二叉樹的前序遍歷。

//二叉樹的非遞歸深度遍歷
//基本思想：用棧,循環 模擬遞歸遍歷的操作
//如果存在左節點，則一直將左節點壓入棧，沒有才壓右節點
#include <iostream>
#include <stack>
using namespace std;

struct node
{
    int value;
    node *left;
    node *right;
};

node* build_tree()
{
    int a;
    cin >> a;
    if(a == 0)
    {
        return NULL;
    }
    node *root = new node();
    root->value = a;
    root->left = build_tree();
    root->right = build_tree();
    return root;
}
void traverse(node *root)
{
    stack<node *> backtrack;
    while(root || !backtrack.empty())
    {
        if(root)
        {
            cout << root->value;
            backtrack.push(root);
            root = root->left;
        }else
        {
            root = backtrack.top();
            backtrack.pop();
            root = root->right;
        }
    }
}
int main()
{
    node *root = build_tree();
    traverse(root);
    return 0;
}

整數字符串轉化

//整數字符串轉化


#include <iostream>
#include <ctime>
using namespace std;
const int N = 10000;

void myItoa(int n)
{
    char str[N];
    int i = 0;
    while(n)
    {
        str[i++] = n % 10 + '0';
        n = n / 10;
    }
    int k = 0, j = i -1;
    while(k < j)
    {
        swap(str[k],str[j]);
        k++;
        j--;
    }
    str[i] = '\0';
    cout << str << endl;
}

int main()
{
    myItoa(10);
}

字符串整數轉化

#include <iostream>
#include <ctime>
using namespace std;
const int N = 10000;

void myAtoi(char *a)
{
    int sum = 0;
    int len = strlen(a);
    for(int i = len - 1, j = 1; i >= 0; i--,j *= 10)
    {
        sum += (a[i] - '0') * j;
    }
    cout << sum << endl;
}

int main()
{
    myAtoi("1020");
}

字符串拷貝函數

#include <iostream>
#include <ctime>
#include <cassert>
using namespace std;
const int N = 10000;

char *strcpy(char *dest, char *src)
{
    char *cp = dest;
    while( *cp++ = *src++)
        ;
    return dest;
}

int main()
{
    char test[] = "123";
    char dest[100];
    cout << strcpy(dest, test);

}

字符串循環右移n位

//先整體反轉，再局部反轉

#include <iostream>
#include <ctime>
#include <cassert>
using namespace std;
const int N = 10000;
void rev(char *p, int b, int e)
{
    while(b < e)
    {
        swap(p[b++],p[e--]);
    }
}

void shift(char *p, int n)
{
    rev(p, 0, strlen(p) - 1);
    rev(p, 0, n - 1);
    rev(p, n,  strlen(p) - 1);
}

int main()
{
    char a[] = "abcdefghi";
    shift(a,2);
    cout << a << endl;

}

最長公共子序列

//dp
c[i, j] =            0         i == 0 或 j == 0

c[i, j] =            c[ i - 1, j - 1] + 1           i, j >0 && xi == yj

c[i, j] =            max( c[ i - 1, j ], c[ i, j - 1 ] )                i, j>0 && i != j

輸入一字符串，找出其中出現的相同且長度最長的字符串

//轉自網上，用了O(n^3)的方法
//ps：正規解法應該用字典樹
#include "iostream"
#include "string"
using namespace std;


int main()
{
    string strInput;
    cout << "Input a string: " << endl;
    cin >> strInput;
    string strTemp;
    for (size_t i = strInput.length() - 1; i > 1; i--)
    {
        for (size_t j = 0; j < strInput.length(); j++)
        {
            if ((i + j) <= strInput.length())
            {
                size_t szForw = 0;
                size_t szBacw = 0;
                strTemp = strInput.substr(j, i);
                szForw = strInput.find(strTemp);
                szBacw = strInput.rfind(strTemp);
                if (szBacw != szForw)
                {
                    cout << strTemp << " " << szForw + 1 << endl;
                    return 0;
                }
            }
        }
    }

    return 1;
}

校門外的樹

某校大門外長度爲L的馬路上有一排樹，每兩棵相鄰的樹之間的間隔都是1米。我們可以把馬路看成一個數軸，馬路的一端在數軸0的位置，另一端在L的位置；數軸上的每個整數點，即0，1，2，……，L，都種有一棵樹。

由於馬路上有一些區域要用來建地鐵。這些區域用它們在數軸上的起始點和終止點表示。已知任一區域的起始點和終止點的座標都是整數，區域之間可能有重合的部分。現在要把這些區域中的樹（包括區域端點處的兩棵樹）移走。你的任務是計算將這些樹都移走後，馬路上還有多少棵樹。

//基本思想：位圖法

#include <iostream>
#include <bitset>
using namespace std;

const int N = 10000;
struct Segment
{
    int start;
    int end;
};

int coverage(Segment *segments, int n)
{
    bool c[N];
    memset(c, 0, sizeof(c));
    int end = 0;
    for(int i = 0; i < n; i++)
    {
        for(int j = segments[i].start; j < segments[i].end; j++)
        {
            c[j] = true;
        }
        if(segments[i].end > end)
            end = segments[i].end;
    }
    int max = 0;
    for(int i= 0; i < end; i++)
    {
        int count = 1;
        if(c[i] == true)
        {
            while(c[++i] == true)
            {
                count++;
            }
        }
        if(count > max)
            max= count;
    }
    return max;
};

int main()
{
    Segment s1;
    s1.start = 0;
    s1.end = 5;
    Segment s2;
    s2.start = 6;
    s2.end = 7;
    Segment ss[] = {s1,s2};
    cout << coverage(ss, 2);
}

Suppose there  is a two-dimension array  a[1 .. 60,1 .. 70] with 60 rows and 70 
columns ,whose main order is the column order(以列序爲主序). If the base address is 10000 
and each element occupies two storage unit, then the storage address of a[32,58] is ( ). (無第
0 行第 0 列元素) 
A)14454      B)16904      C)16902      D) None of above 

Sorting the  sequence (25,84,21,47,15,27,68,35,20) , the sequence changes  are 
(20,15,21,25,47,27,68,35,84)，(15,20,21,25,35,27,47,68,84)，(15,20,21,25,27,35,47,68,84). 
Which kind of sorting algorithm we used ? ( ) 
 A) Selection sort    B) shell sort    C) merge sort    D) quick sort 

怎樣編寫一個程序，把一個有序整數數組放到二叉樹中？

#include <iostream>
using namespace std;

struct Node
{
    int value;
    Node *left;
    Node *right;
};
void binaryTree(Node *&root, int a[], int n)
{
    if(n > 0)
    {
        root = new Node();
        root->value = a[n/2];
        binaryTree(root->left , a,  n/2 );
        binaryTree(root->right, a + n/2 + 1, n - n/2 - 1);
    }else
    {
        root = NULL;
    }
}
void display(Node *root)
{
    if(!root)
        return ;
    display(root->left);
    cout << root->value << " ";
    display(root->right);
}
int main()
{
    int a[] = {1,2,3,4,5};
    Node *root = NULL;
    binaryTree(root, a, 5);
    display(root);
}

給出一個函數來輸出一個字符串的所有排列。

//基本思想：遞歸
//從要全排列的字符串中取出一個字符，加入到prefix字符串中
//然後遞歸
//當要全排列的字符串爲空時，就可以輸出prefix字符串了。
#include <iostream>
#include <string>
using namespace std;

void permut(string pre, string toPermut)
{
    if(toPermut.length() == 0)
        cout << pre << endl;
    else
    {
        for(int i = 0; i < toPermut.length(); i++)
        {
            permut(pre + toPermut[i], toPermut.substr(0,i)+toPermut.substr(i+1,toPermut.length()));
        }
    }
}
void print(string str)
{
    permut("",str);
}

int main(void)
{
    print("abc");
    return 0;
}

在鏈表裏如何發現循環鏈接？

//基本思想：快慢指針
#include <iostream>
#include <string>
using namespace std;

struct Node
{
    int value;
    Node *next;
};
bool hasCircle(Node *head)
{
    Node *fast;
    Node *slow;
    fast = slow = head;
    if(head == NULL  || head->next == NULL)
        return false;
    do
    {
        fast = fast->next;
        fast = fast->next;
        slow = slow->next;
    }while(fast != NULL && fast != slow);
    return !(fast == NULL);
}

int main(void)
{
    Node *head = new Node();
    head->value = 1;
    Node *tem = head->next = new Node();
    tem->value = 2;
    tem->next = head;
    cout << hasCircle(head);
    return 0;
}

給出一個單鏈表，不知道結點N的值，怎樣只遍歷一次就可以求出中間結點，寫出算法。

//基本思路：快慢指針。
#include <iostream>
#include <ctime>
using namespace std;
struct Node
{
    int value;
    Node *next;
};
int middle(Node *head)
{
    Node *slow, *fast;
    slow = fast = head;
    while(fast && fast->next)
    {
        fast = fast->next->next;
        slow = slow->next;
    }
    return slow->value;
}

尋找最大的k個數

//基本思路：部分快速排序
#include <iostream>
using namespace std;

int partition(int *a, int b, int e)
{
    int j = b - 1 ;
    for(int i = b; i < e - 1; i++)
    {
        if(a[i] < a[e-1])
        {
            j++;
        }else
        {
            int tem = a[++j];
            a[j] = a[i];
            a[i] = tem;
        }
    }
    int tem = a[++j];
    a[j] = a[e - 1];
    a[e - 1] = tem;
    return j;
}
void find(int *a, int s, int k)
{
    int p = partition(a, 0, s);
    int c = s - p;
    if(c == k)
    {
        for(int i = p; i < s; i++)
        {
            cout << a[i] << " ";
        }
    }else if(c < k)
    {
        for(int i = p; i < s; i++)
        {
            cout << a[i] << " ";
        }
        find(a, p, k - c);
    }else if(c > k)
    {
        find(a+p, s - p, k);
    }
}
int main()
{
    int a[] = {1,2,3};
    find(a, 3, 2);
}