Пример #1
0
        private innerTreeNode BuiltTree(int[] nums, int startIndex, int endIndex)
        {
            if (startIndex > endIndex)
            {
                return(null);
            }
            else
            {
                innerTreeNode returnValue = new innerTreeNode();
                returnValue.startIndex = startIndex;
                returnValue.endIndex   = endIndex;

                if (startIndex == endIndex)
                {
                    returnValue.sum = nums[startIndex];
                }
                else
                {
                    int midIndex = startIndex + (endIndex - startIndex) / 2;

                    returnValue.LeftNode = BuiltTree(nums, startIndex, midIndex);

                    returnValue.RightNode = BuiltTree(nums, midIndex + 1, endIndex);

                    returnValue.sum = returnValue.LeftNode.sum + returnValue.RightNode.sum;
                }

                return(returnValue);
            }
        }
Пример #2
0
        private void Update(innerTreeNode useNode, int useIndex, int useValue)
        {
            if (useNode.startIndex == useNode.endIndex)
            {
                useNode.sum = useValue;
            }
            else
            {
                int midIndex = useNode.startIndex + (useNode.endIndex - useNode.startIndex) / 2;

                if (useIndex <= midIndex)
                {
                    Update(useNode.LeftNode, useIndex, useValue);
                }
                else
                {
                    Update(useNode.RightNode, useIndex, useValue);
                }

                useNode.sum = useNode.LeftNode.sum + useNode.RightNode.sum;
            }
        }
Пример #3
0
        private int CalculateSum(innerTreeNode useNode, int i, int j)
        {
            if (useNode.startIndex == i && useNode.endIndex == j)
            {
                return(useNode.sum);
            }
            else
            {
                int midIndex = useNode.startIndex + (useNode.endIndex - useNode.startIndex) / 2;

                if (j <= midIndex)
                {
                    return(CalculateSum(useNode.LeftNode, i, j));
                }
                else if (i >= midIndex + 1)
                {
                    return(CalculateSum(useNode.RightNode, i, j));
                }
                else
                {
                    return(CalculateSum(useNode.RightNode, midIndex + 1, j) + CalculateSum(useNode.LeftNode, i, midIndex));
                }
            }
        }
Пример #4
0
 public NumArray(int[] nums)
 {
     m_rootNode = BuiltTree(nums, 0, nums.Length - 1);
 }