leetcode算法题思路源码汇总(100~150题)---tree的操作

题目：102. Binary Tree Level Order Traversal

Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).

解题思路：

int getTreeTall(struct TreeNode* root)
{
    int tall = 0;
    if (root == NULL)
    {
        return 0;
    }
    
    return 1 + (getTreeTall(root->left) > getTreeTall(root->right) ? 
                getTreeTall(root->left) :getTreeTall(root->right));
}

int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
    // get tree 
    int i,j,k;
    int treeTall = 1000;
    if (root == NULL)
    {
        treeTall = 0;
    }
    //printf ("tall =%d\n", treeTall);
    *returnSize = treeTall;
    *returnColumnSizes = (int*)malloc(sizeof(int)* treeTall); 
    
    int** res = (int**)malloc(sizeof(int*) * treeTall);
    int curMaxLen = 1;
    struct TreeNode** vect = (struct TreeNode**)malloc(sizeof(struct TreeNode*) * curMaxLen);
    vect[0] = root;
    int curlen = 1;
    for (i = 1; i <= treeTall; i++)
    {
        // printf ("curlen =%d\n", i);
        res[i - 1] = (int*)malloc(sizeof(int)*curlen);
        (*returnColumnSizes)[i - 1] = curlen;
        for (j = 0; j < curlen; j++)
        {
            res[i - 1][j] = vect[j]->val;
            //printf("%d %d = %d\n", i -1, j,  res[i - 1][j] );
        }
        if ( i == treeTall)
        {
            break;
        }
        curMaxLen = curlen * 2;
        //*returnSize = i;
        struct TreeNode** tmp = (struct TreeNode**)malloc(sizeof(struct TreeNode*) * curMaxLen);
        k = 0;
        for (j = 0; j < curlen; j++)
        {
            if (vect[j]->left != NULL)
                tmp[k++] = vect[j]->left;
            
             if (vect[j]->right != NULL)
                tmp[k++] = vect[j]->right;
           
        }
        curlen = k;
      
        free(vect);
        vect = tmp;
       if (k == 0)
       {
           break;
       }
    }
    if (vect != NULL)
    { 
        free (vect);
       
    }
    if (treeTall == 0)
    *returnSize = 0;
    else
        *returnSize = i;
  return res;
    
}

 

题目：105. Construct Binary Tree from Preorder and Inorder Traversal

Given preorder and inorder traversal of a tree, construct the binary tree.

Note:
You may assume that duplicates do not exist in the tree.

For example, given

preorder = [3,9,20,15,7]
inorder = [9,3,15,20,7]

Return the following binary tree:

    3
   / \
  9  20
    /  \
   15   7

解题思路： 理解前序遍历和中序遍历原理，此题不难。代码中没有处理异常条件下的内存释放问题。做法不够严谨，但是可以AC。

struct TreeNode* buildTree(int* preorder, int preorderSize, int* inorder, int inorderSize){
    if (preorder== NULL || inorder== NULL || preorderSize == 0 || inorderSize == 0)
    {
        return NULL;
    }
    int i;
    for (i = 0; i < inorderSize; i++)
    {
        if (inorder[i] == preorder[0])
        {
            break;
        }
    }
    if (i == inorderSize)
    {
        return NULL;
    }
    
    struct TreeNode* node = (struct treeNode*)malloc(sizeof(struct TreeNode));
    node->val = preorder[0];
    
    node->left = buildTree(preorder + 1, i, inorder, i);
    node->right = buildTree(preorder + 1 + i, preorderSize - i - 1, inorder + 1 + i, inorderSize - i - 1);
    return node;
}

106. Construct Binary Tree from Inorder and Postorder Traversal

Given inorder and postorder traversal of a tree, construct the binary tree.

Note:
You may assume that duplicates do not exist in the tree.

For example, given

inorder = [9,3,15,20,7]
postorder = [9,15,7,20,3]

Return the following binary tree:

    3
   / \
  9  20
    /  \
   15   7
解题思路：同105题

struct TreeNode* buildTree(int* inorder, int inorderSize, int* postorder, int postorderSize){
    if ( inorderSize==0 || postorderSize==0)
    {
        return NULL;
    }
    
    int i;
    for (i = 0; i < inorderSize; i++)
    {
        if (inorder[i] == postorder[postorderSize-1])
        {
            break;
        }
    }
    
    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->val = inorder[i];
    root->left = buildTree(inorder, i, postorder, i);
    root->right= buildTree(inorder + i + 1, inorderSize -i - 1, postorder + i, postorderSize - i - 1);
    return root;

}

 

113. Path Sum II

Given a binary tree and a sum, find all root-to-leaf paths where each path's sum equals the given sum.

Note: A leaf is a node with no children.

Example:

Given the below binary tree and sum = 22,

      5
     / \
    4   8
   /   / \
  11  13  4
 /  \    / \
7    2  5   1

Return:

[
   [5,4,11,2],
   [5,8,4,5]
]

class Solution {
public:
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        vector<vector<int>> result;
        vector<int> path;
        getAllPathSum(root, result, sum, path, 0);
        return result;
    }
private:
    void getAllPathSum(TreeNode* root, vector<vector<int>> &result, int sum,
                        vector<int> &path, int cur)
    {
        if (root == NULL)
        {
            return;
        }
        
        path.push_back(root->val);
        
        if (root->left != NULL)
        {
            getAllPathSum(root->left, result, sum, path, cur + root->val);
        }
        if (root->right != NULL)
        {
            getAllPathSum(root->right, result, sum, path, cur + root->val);
        }
        if (root->right == NULL && root->left == NULL)
        {
            cur += root->val;
            if (cur == sum)
            {
                result.push_back(path);
            }
        }
        path.pop_back();
        
    }
};

 

119. Pascal's Triangle II

Given a non-negative index k where k ≤ 33, return the kth index row of the Pascal's triangle.

Note that the row index starts from 0.

解题思路：

int* getRow(int rowIndex, int* returnSize){
  
    *returnSize = rowIndex+1;
    int size = *returnSize;
    int* result = (int*)malloc(sizeof(int) * size);
    
    for (int i = 0; i < size; i++)
    {
        result[i] = 1;
    }
    
    //result[0] = 1;
    for (int i = 1; i < size; i++)
    {
        result[0] = 1;
        result[i] = 1;
        for(int j = i - 1; j > 0; j--)
        {
            result[j] = result[j] + result[j-1];
        }
    }
    
    return result;
}

 

121. Best Time to Buy and Sell Stock

Say you have an array for which the ith element is the price of a given stock on day i.

If you were only permitted to complete at most one transaction (i.e., buy one and sell one share of the stock), design an algorithm to find the maximum profit.

Note that you cannot sell a stock before you buy one.

解题思路：

典型的动态规划题目。

找到状态转移方程。dy(x+1)=max{d(x), price(x+1)-minprice(x)}。dy(x)表示前x天获取的最大收益，price(x)表示当天股票的价格，minprice(x)表示前x天里股票的最小价格。本题需要同时更新两个状态数组dy和minprice。

代码略。

122. Best Time to Buy and Sell Stock II

解题思路：受第一题影响，以为这一题要用动态规划，思虑甚久仍不得其解，参考别人的做法，这题主要用贪心算法 。从前往后遍历数组，只有当前股票价格比前一天高，价格差则计入最大利润。碰到何种题型该用何种算法，鄙人暂时还没有好的总结和想法。

int maxProfit(int* prices, int pricesSize){
    int maxprofit = 0;
    for (int i = 1; i < pricesSize; i++)
    {
        if (prices[i] - prices[i-1] > 0)
        {
            maxprofit += prices[i] - prices[i-1];
        }
    }
    return maxprofit;
}

123. Best Time to Buy and Sell Stock III

解题思路：仔细观察此题，此题与121. Best Time to Buy and Sell Stock唯一不同的地方是允许最多两次交易。可以将原数组拆分为两个数组，每个数组运用121题的思路，可以计算出两个数组各自最大profit。原数组可以有N种拆分，比较N种拆分的最大profit，从而得到最佳profit.

int maxProfit(int* prices, int pricesSize){
// 这一题可以拆分为两个数组
    if (pricesSize <= 1)
    {
        return 0;
    }
    int* headMaxProfit = (int*)malloc(pricesSize * sizeof(int));
    int* tailMaxProfit = (int*)malloc(pricesSize * sizeof(int));
    int* minprices =   (int*)malloc(pricesSize * sizeof(int));
    int* maxprices =   (int*)malloc(pricesSize * sizeof(int));
    for (int i = 0; i < pricesSize; i++)
    {
         headMaxProfit[i] = 0;
         tailMaxProfit[i] = 0;
         minprices[i] = 99999999;
         maxprices[i] = 0;
    }
    
    minprices[0] = prices[0];
    for (int i = 1; i < pricesSize; i++)
    {
        if (prices[i] - minprices[i-1] > headMaxProfit[i-1])
        {
            headMaxProfit[i] = prices[i] - minprices[i-1];
        }
        else
        {
             headMaxProfit[i] =  headMaxProfit[i-1];
        }
        
        if (prices[i] < minprices[i-1])
        {
            minprices[i] = prices[i];
        }
        else
        {
            minprices[i] = minprices[i-1];
        }
    }
    
    maxprices[pricesSize-1] = prices[pricesSize-1];
    for (int i = pricesSize - 2; i >= 0; i--)
    {
        if (maxprices[i+1] - prices[i] > tailMaxProfit[i+1])
        {
            tailMaxProfit[i] = maxprices[i+1] - prices[i];
        }
        else
        {
            tailMaxProfit[i] =  tailMaxProfit[i+1];
        }
        
        if (maxprices[i+1] > prices[i])
        {
            maxprices[i] = maxprices[i+1];
        }
        else
        {
            maxprices[i] = prices[i];
        }
    }
    
    
    int result = headMaxProfit[pricesSize-1];
    
    for (int i = 1; i < pricesSize-1; i++)
    {
        if (headMaxProfit[i] + tailMaxProfit[i+1] > result)
        {
            result = headMaxProfit[i] + tailMaxProfit[i+1];
        }
    }
    
    free(headMaxProfit);
    free(tailMaxProfit);
    free(maxprices);
    free(minprices);
    
    return result;
}

137. Single Number II

Given a non-empty array of integers, every element appears three times except for one, which appears exactly once. Find that single one.

Note:

Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?

Example 1:

Input: [2,2,3,2]
Output: 3

解题思路：这题也是百思不得其解，看到网上一个巧妙的算法，茅塞顿开。

这题目的输入是int型数字，我们可以用一个int bitarray[32]表示数组中所有数字的相应bit位为1的个数之和。例如，bitarray[5] =  3表示所有数字第5 bit位为1出现的次数为 3。对于bitarray[32]，每个元素值对3取余，值要么为0，要么为1，为2的话表示输入有误，不予考虑。对bitarray各元素对3取余，之后将数组转化成对应的整数，即为single one。

int singleNumber(int* nums, int numsSize){
    
    int bitarray[32] = {0};
    
    for (int i = 0; i < numsSize; i++)
    {
        for (int j = 0; j < 32; j++)
        {
            if ((nums[i] & ((unsigned int)1 << j)) != 0)
            {
                bitarray[j]++;
            }
        }
    }
    
    int sum = 0;
    for (int i = 0; i < 32; i++)
    {
        if (bitarray[i] % 3 == 1)
        {
            sum += (unsigned int)1 << i;
        }
    }
    return sum;
}