最左原位、完全二叉树计数、快速N次方

最左原位
完全二叉树计数
快速N次方

最左原位
有一个有序数组arr，其中不含有重复元素，请找到满足arr[i]==i条件的最左的位置。如果所有位置上的数都不满足条件，返回-1。
给定有序数组arr及它的大小n，请返回所求值。
测试样例：
[-1,0,2,3],4
返回：2
我的提交

-- coding:utf-8 --

class Find:
def findPos(self, arr, n):

write code here

    if n <= 0 or arr[0] > 0 or arr[n-1] < n - 1:
        return -1

    res = -1
    left = 0
    right = n - 1

    while left < right:
        mid = left + (right - left) // 2
        if arr[mid] == mid:
            res = mid
            right = mid
        elif arr[mid] < mid:
            left = mid + 1
        else:
            right = mid - 1
    if arr[left] == left:
        res = left
    return res

if name == 'main':
f = Find()
print(f.findPos([-1,0,2,3],4))
参考答案
import java.util.*;

public class Find {
public int findPos(int[] arr, int n) {
if (arr == null || n == 0) {
return -1;
}
int left = 0;
int right = n - 1;
int res = -1;
while (left <= right) {
if (arr[left] > left || arr[right] < right) {
break;
}
int mid = (left + right) / 2;
if (arr[mid] < mid) {
left = mid + 1;
} else if (arr[mid] > mid) {
right = mid - 1;
} else {
res = mid;
right = mid - 1;
}
}
return res;
}

完全二叉树计数
给定一棵完全二叉树的根节点root，返回这棵树的节点个数。如果完全二叉树的节点数为N，请实现时间复杂度低于O(N)的解法。
给定树的根结点root，请返回树的大小。
我的提交

-- coding:utf-8 --

class TreeNode:

def init(self, x):

self.val = x

self.left = None

self.right = None

class CountNodes:
def count(self, root):

write code here

    if not root:
        return 0
    count = self.isCompleteTree(root)

    if count != 0:
        return count
    else:
        return self.CountNodes(root.left) + self.CountNodes(root.right) + 1

def isCompleteTree(self, root):
    if not root:
        return 0
    t = root
    left = 0
    while t:
        left += 1
        t = t.left

    t = root
    right = 0
    while t:
        right += 1
        t = t.right
    if left == right:
        return pow(2, left) - 1
    else:
        return 0

参考答案
import java.util.*;

/
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}/
public class CountNodes {
public int count(TreeNode head) {
if (head == null) {
return 0;
}
return bs(head, 1, mostLeftLevel(head, 1));
}

public int bs(TreeNode node, int l, int h) {
    if (l == h) {
        return 1;
    }
    if (mostLeftLevel(node.right, l + 1) == h) {
        return (1 << (h - l)) + bs(node.right, l + 1, h);
    } else {
        return (1 << (h - l - 1)) + bs(node.left, l + 1, h);
    }
}

public int mostLeftLevel(TreeNode node, int level) {
    while (node != null) {
        level++;
        node = node.left;
    }
    return level - 1;
}

}

快速N次方
如果更快的求一个整数k的n次方。如果两个整数相乘并得到结果的时间复杂度为O(1)，得到整数k的N次方的过程请实现时间复杂度为O(logN)的方法。
给定k和n，请返回k的n次方，为了防止溢出，请返回结果Mod 1000000007的值。

测试样例：

2,3

返回：8

参考答案
python

-- coding:utf-8 --

class QuickPower:
def getPower(self, k, N):
s,t = 1,k
while N:
if N & 1:
s = (st)%1000000007
t = (tt)%1000000007
N = N >> 1
return s
java
import java.util.*;
import java.math.BigInteger;

public class QuickPower {
public int getPower(int a, int n) {
BigInteger res = BigInteger.valueOf(1);
BigInteger tmp = BigInteger.valueOf(a);
for (; n != 0; n >>= 1) {
if ((n & 1) != 0) {
res = res.multiply(tmp);
}
tmp = tmp.multiply(tmp);
res = res.mod(BigInteger.valueOf(1000000007));
tmp = tmp.mod(BigInteger.valueOf(1000000007));
}
return res.mod(BigInteger.valueOf(1000000007)).intValue();
}
}

转载于:https://blog.51cto.com/13545923/2054449