Ordered single-chain table to BST tree + time complexity requirements O (n), single-chain bst

Ordered single-chain table to BST tree + time complexity requirements O (n), single-chain bst
Problem description

There are usually multiple methods to convert an ordered array or linked list into a relatively balanced BST tree.
1. when an ordered array A is converted into a bst, convert the element A [m] in the middle of the array to the root, and then recursively convert it to A [1 .. m-1], A [m + 1 .. n. Time Complexity T (n) = 2 * T (n/2) + O (1), T (n) = O (n)
2. For ordered linked lists, you can also perform this operation based on the above method. However, to get A [m], we need to traverse the n/2 length array, so we need additional O (n) Time to get A [m]. Therefore, the time complexity is T (n) = 2 * T (n/2) + O (n), and T (n) = n log (n) is obtained ).
OK. The problem arises. If we want to convert the ordered linked list to BST, it will also be O (n) time, what should we do?

Solution

For the issue of ordered linked list, you can refer to the recursive solution. The difference is that when performing left half-side recursion, the head node of the single-chain table is updated at the same time.
When LinkNode * head is input as a parameter, after the conversion is complete, the head will be changed to the End Node of the single-chain table-> next, that is, NULL. When a LinkNode node is processed each time, the head needs to shift one node to the right. The details are as follows:

# Include <iostream> # include <cstdio> # include <cstdlib> # include <algorithm> # include <vector> # include <cstring> using namespace std; // The node Structure struct LinkNode {int value; LinkNode * next; LinkNode (int v): value (v), next (NULL ){}}; // BST node Structure struct BstNode {int value; BstNode * left, * right; BstNode (int v): value (v), left (NULL), right (NULL) {}}; class Solution {public: void solve () {// test case int arr [] = {1, 2, 3, 4, 5, 6, 7}; LinkNode * head = NULL, * p = NULL; for (int I = 0; I <sizeof (arr)/sizeof (int); I ++) {if (head = NULL) head = p = new LinkNode (arr [I]); else p-> next = new LinkNode (arr [I]), p = p-> next ;} bstNode * root = convert (head, 0, sizeof (arr)/sizeof (int)-1); printBstNode (root); printf ("\ n ");} // move ahead the head pointer when carrying out the inorder traversal. // in this way, we avoid n * log (n) time complexity BstNode * convert (LinkNode * & head, int s, int e) {BstNode * root = NULL; if (s> e) {} else if (s = e) {root = new BstNode (head-> value); head = head-> next ;} else {int m = s + (e-s)/2; BstNode * left = convert (head, s m-1); root = new BstNode (head-> value ); head = head-> next; BstNode * right = convert (head, m + 1, e); root-> left = left; root-> right = right ;} return root;} // for printing out the content of a BstNode tree, inorder printing void printBstNode (BstNode * root) {if (root = NULL) return; printBstNode (root-> left); printf ("% d", root-> value); printBstNode (root-> right) ;}}; int main () {Solution; solution. solve ();}