Insert sorted array into binary search tree

Question

I want to implement an algorithm that inserts sorted arrays into binary search trees but I don't want ending up with a tree that only grows to one side.

Do you have any ideas?

Thanks.

score 11 · Accepted Answer · answered Oct 16 '13 at 10:07

11

This should give you a balanced tree (in O(n)):

Construct a node for the middle element in the array and return it
(this will be the root in the base case).
Repeat from 1. on the left half of the array, assigning the return value to the left child of the root.
Repeat from 1. on the right half of the array, assigning the return value to the right child of the root.

Java-like code:

TreeNode sortedArrayToBST(int arr[], int start, int end) {
  if (start > end) return null;
  // same as (start+end)/2, avoids overflow.
  int mid = start + (end - start) / 2;
  TreeNode node = new TreeNode(arr[mid]);
  node.left = sortedArrayToBST(arr, start, mid-1);
  node.right = sortedArrayToBST(arr, mid+1, end);
  return node;
}

TreeNode sortedArrayToBST(int arr[]) {
  return sortedArrayToBST(arr, 0, arr.length-1);
}

Code derived from here.

answered Oct 16 '13 at 10:07

Bernhard Barker

54,589
14
104
138

sir , what would be the time complexity if there was no restricton of balanced binary search tree?should it be O(n) only? – laura Aug 28 '17 at 11:55
i mean could have make skewed tree by the given sorted input.what would be its time complexity? – laura Aug 28 '17 at 12:04
1

@laura It will also take O(n) to construct an unbalanced tree. Simply going through the input array once takes O(n), so there's no way to do better than that. – Bernhard Barker Aug 28 '17 at 12:06
sir , one more request .can you please provide me recurrence relation for your given algorithm .I want to derive the worst case time complexity :) – laura Aug 28 '17 at 12:08
1

@laura It seems to be `T(n) = 2T(n/2) + 1`. – Bernhard Barker Aug 28 '17 at 12:18

score 4 · Answer 2 · answered Oct 17 '13 at 05:40

public class SortedArrayToBST {
    public TreeNode sortedArrayToBST(int[] num) {
        if (num == null) {
            return null;
        }
        return buildBST(num, 0, num.length - 1);
    }

    private TreeNode buildBST(int[] num, int start, int end) {
        if (start > end) {
            return null;
        }
        int mid = start + (end - start) / 2;
        TreeNode root = new TreeNode(num[mid]);
        TreeNode left = buildBST(num, start, mid - 1);
        TreeNode right = buildBST(num, mid + 1, end);
        root.left = left;
        root.right = right;
        return root;
    }
}

score 0 · Answer 3 · answered Oct 16 '13 at 09:42

Insert them in pseudo-random order, like here:

#include <stdio.h>

int array[] = {1,2,3,4,5,6,7,8,9,10};

#define COUNT 10
#define STEP 7  /* must be relatively prime wrt COUNT */
#define START 5 /* not important */

int main(void)
{
unsigned idx;

idx=START;
while(1) {
        printf("[%u] = %u\n", idx, array[idx] );
        // do_insert(array[idx] );
        idx = (idx + STEP ) % COUNT;
        if (idx == START) break;
        }
return 0;
}

Insert sorted array into binary search tree

3 Answers3

Linked

Related