Create a sorted linked list from the given Binary Tree

<script>

// JavaScript implementation of the approach

// A linked list node
class Node {

    constructor(data)
    {
        this.data = data;
        this.next = null;
    }
};

// A binary tree node
class treeNode {

    constructor(data)
    {
        this.data = data;
        this.left = null;
        this.right = null;
    }
};

// Function to print the linked list
function print(head)
{
    if (head == null) {
        return;
    }
    var temp = head;
    while (temp != null) {
        document.write( temp.data + " ");
        temp = temp.next;
    }
}

// Function to create Linked list from given binary tree
function sortedList(head, root)
{
    // return head if root is null
    if (root == null) {
        return head;
    }

    // First make the sorted linked list
    // of the left sub-tree
    head = sortedList(head, root.left);
    var newNode = new Node(root.data);
    var temp = head;
    var prev = null;

    // If linked list is empty add the
    // node to the head
    if (temp == null) {
        head = newNode;
    }
    else {

        // Find the correct position of the node
        // in the given linked list
        while (temp != null) {
            if (temp.data > root.data) {
                break;
            }
            else {
                prev = temp;
                temp = temp.next;
            }
        }

        // Given node is to be attached
        // at the end of the list
        if (temp == null) {
            prev.next = newNode;
        }
        else {

            // Given node is to be attached
            // at the head of the list
            if (prev == null) {
                newNode.next = temp;
                head = newNode;
            }
            else {

                // Insertion in between the list
                newNode.next = temp;
                prev.next = newNode;
            }
        }
    }

    // Now add the nodes of the right sub-tree
    // to the sorted linked list
    head = sortedList(head, root.right);
    return head;
}

// Driver code

    /* Tree:
         10
        /  \
      15    2
     /  \
    1    5
*/
var root = new treeNode(10);
root.left = new treeNode(15);
root.right = new treeNode(2);
root.left.left = new treeNode(1);
root.left.right = new treeNode(5);
var head = sortedList(null, root);
print(head);


</script>

// JavaScript program for the above approach
// a linked list node
class LNode{
    constructor(data){
        this.data = data;
        this.next = null;
    }
}


// a binary tree node
class TNode{
    constructor(data){
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

// function to print the linked list
function printList(head){
    if(head == null) return;
    let temp = head;
    while(temp != null){
        console.log(temp.data + " ");
        temp = temp.next;
    }
    console.log(" ");
}

// function to store the inorder fashion
function inOrder(root, vec){
    if(root == null) return;
    inOrder(root.left, vec);
    vec.push(root.data);
    inOrder(root.right, vec);
}

// function to create sorted linked list from given binary tree
function sortedList(root){
    // initializing vector to store the elements
    let vec = [];
    inOrder(root, vec);
    vec.sort(function(a,b){return a-b});
    let head = new LNode(-1);
    let temp = head;
    for(let i = 0; i<vec.length; i++){
        temp.next = new LNode(vec[i]);
        temp = temp.next;
    }
    head = head.next;
    return head;
}

// driver program to test above functions
/* Tree:
     10
    /  \
  15    2
 /  \
1    5
*/
let root = new TNode(10);
root.left = new TNode(15);
root.right = new TNode(2);
root.left.left = new TNode(1);
root.left.right = new TNode(5);

let head = sortedList(root);
printList(head);