剑指offer

https://github.com/longf0720/atoffer

单例 是最为最常见的设计模式之一。对于任何时刻，如果某个类只存在且最多存在一个具体的实例，那么我们称这种设计模式为单例。例如，对于 class Mouse (不是动物的mouse哦)，我们应将其设计为 singleton 模式。

你的任务是设计一个 getInstance 方法，对于给定的类，每次调用 getInstance 时，都可得到同一个实例。

//懒汉模式:不到万不得已就不会去实例化类，也就是说在第一次用到类实例的时候才会去实例化
 1 int lock_ = 0;
class Solution {
private:
    static Solution *instance;

private:
    static void Lock() {
        while (lock_) {}
        lock_ = 1;
    }
    static void UnLock() {
        if (lock_) lock_=0;
    }

public:
    /**
     * @return: The same instance of this class every time
     */
    static Solution* getInstance() {
        // write your code here
        if (instance == NULL) {
            Solution::Lock();
            if (instance == NULL) {
              instance = new Solution();
            }
            Solution::UnLock();
        }
        return instance;
    }
};

Solution* Solution::instance = NULL;

//饿汉模式:饿了肯定要饥不择食。所以在单例类定义的时候就进行实例化。
//不用加锁
 1 class singleton
{
protected:
    singleton()
    {}
private:
    static singleton* p;
public:
    static singleton* initance();
};
singleton* singleton::p = new singleton;
singleton* singleton::initance()
{
    return p;
}

 

翻转一个链表

给出一个链表1->2->3->null，这个翻转后的链表为3->2->1->null

 

/**
 * Definition of ListNode
 * 
 * class ListNode {
 * public:
 *     int val;
 *     ListNode *next;
 * 
 *     ListNode(int val) {
 *         this->val = val;
 *         this->next = NULL;
 *     }
 * }
 */
typedef ListNode* List;
class Solution {
public:
    /**
     * @param head: The first node of linked list.
     * @return: The new head of reversed linked list.
     */
    ListNode *reverse(ListNode *head) {
        // write your code here
        if (head == NULL) {
            return NULL;
        }
        if (head->next == NULL) {
            return head;
        }
        List current = head, origin_next = NULL;
        head = NULL;
        while (current != NULL) {
            origin_next = current->next;
            if (head == NULL) {
                head = current;
                head->next = NULL;
            } else {
                // 头插法
                ListNode *tmp = head;
                head = current;
                head->next = tmp;
            }
            current = origin_next;
        }
        return head;
    }
};

 

根据前序遍历和中序遍历树构造二叉树.

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
    /**
     *@param preorder : A list of integers that preorder traversal of a tree
     *@param inorder : A list of integers that inorder traversal of a tree
     *@return : Root of a tree
     */
public:
    TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
        // write your code here
        if (preorder.size() == 0 || inorder.size() == 0) {
            return NULL;
        } else if (preorder.size() != inorder.size()) {
            return NULL;
        } else {
            int root = preorder.at(0);
            // cout<<"root="<<root<<endl;
            // find root in inorder, and split it
            int l_node_counter = 0;
            for (auto item : inorder) {
                if (item == root) {
                    break;
                }
                l_node_counter++;
            }
            if (l_node_counter == preorder.size()) {
                // cann't find root in inorder
                // throw std::exception("Invalid Input");
                perror("Invalid input.");
                exit(-1);
            }
            // cout<<"node amount in left tree is:"<<l_node_counter<<endl;
            // build left Tree
            vector<int> l_preorder;
            vector<int> l_inorder;
            for (int i = 1; i <= l_node_counter; i++) {
                l_preorder.push_back(preorder.at(i));
            }
            for (int i = 0; i < l_node_counter; i++) {
                l_inorder.push_back(inorder.at(i));
            }
            TreeNode *lchild = buildTree(l_preorder, l_inorder);
            // build right Tree
            vector<int> r_preorder;
            vector<int> r_inorder;
            for (int i = l_node_counter + 1; i < preorder.size(); i++) {
                r_preorder.push_back(preorder.at(i));
            }
            for (int i = l_node_counter + 1; i < inorder.size(); i++) {
                r_inorder.push_back(inorder.at(i));
            }
            TreeNode *rchild = buildTree(r_preorder, r_inorder);
            // build root
            TreeNode *rootNode = new TreeNode(root);
            if (rootNode == NULL) {
                perror("new TreeNode failed, memory not enough");
            } else {
                rootNode->left = lchild;
                rootNode->right = rchild;
            }
            return rootNode;
        }
    }
};