Note 1

Take Note:

Take a note while surfing.





Note With Ink

Give your Note a Colorful Tag.




Easy to Access

Stay on same information and in Sync wherever you are.

Note 2

Take Note:

Organize your information,It may take Shape.





Think With Ink

Differ your Content by Color.




Easy to Access

Easy to pull up your content from anywhere anytime.

Note 3

Take Note:

Don't Let information to miss,Because it take shape





Note With Ink

Simple an Easy Way to take a note.




Easy to Access

Get the same in next visit.

Programs Questions and Answers



  • 31. Write an efficient program to traverse the list N nodes from the tail

    Input : ,   Output :

    View Answer View Answer | Program Topics Linked List | Write Your Program Discuss in Forum | Add to Reading List To Reading List | Tag to companies Asked In | Level Fresher
  • Answer In: C  
     
    #include<stdio.h>
    #include<stdlib.h>

    /* Link list node */
    struct Node
    {
    int data;
    struct Node* next;
    };

    /* Function to get the nth node from the last of a linked list*/
    void printNthFromLast(struct Node* head, int n)
    {
        int len = 0, i;
        struct Node *temp = head;

        // 1) count the number of nodes in Linked List
        while (temp != NULL)
        {
            temp = temp->next;
            len++;
        }

        // check if value of n is not more than length of the linked list
        if (len < n)
        return;

        temp = head;

        // 2) get the (n-len+1)th node from the begining
        for (i = 1; i < len-n+1; i++)
        temp = temp->next;

        printf ("%d", temp->data);

        return;
    }

    void push(struct Node** head_ref, int new_data)
    {
    /* allocate node */
    struct Node* new_node =
            (struct Node*) malloc(sizeof(struct Node));

    /* put in the data */
    new_node->data = new_data;

    /* link the old list off the new node */
    new_node->next = (*head_ref);

    /* move the head to point to the new node */
    (*head_ref) = new_node;
    }

    /* Drier program to test above function*/
    int main()
    {
    /* Start with the empty list */
    struct Node* head = NULL;

    // create linked 35->15->4->20
    push(&head, 20);
    push(&head, 4);
    push(&head, 15);
    push(&head, 35);

    printNthFromLast(head, 5);
    return 0; 
    }
    Tags:

    No Tags on this question yet!

  • 32. Write a program insert an element into ascending order list

    Input : ,   Output :

    View Answer View Answer | Program Topics Linked List | Write Your Program Discuss in Forum | Add to Reading List To Reading List | Tag to companies Asked In | Level Fresher
  • Answer In: C   C++  
     
    #include <stdio.h>
    
     #include<iostream>
    using namespace std; 
    void main()
    {
        int i, j, a, n, number[30]; 
        cout<<"Enter the value of N \n";
        cin>>n;
        cout<<"Enter the numbers \n";
        for (i = 0; i < n; ++i)
            cin>>number[i];
        for (i = 0; i < n; ++i)
        {
            for (j = i + 1; j < n; ++j)
            {
                if (number[i] > number[j])
                {
                    a =  number[i];
                    number[i] = number[j];
                    number[j] = a;
                }
            }
        }
         cout<<"The numbers arranged in ascending order are given below \n";
        for (i = 0; i < n; ++i)
             cout<< number[i];
    }
    Tags:

    Virtusa 

  • 33. Write a program to reverse the single linked list

    Input : ,   Output :

    View Answer View Answer | Program Topics Linked List | Write Your Program Discuss in Forum | Add to Reading List To Reading List | Tag to companies Asked In | Level Fresher
  • Answer In: C   C++  
     
    #include <iostream>
    #include <cstddef>
    /* definition of the list node class */
    class Node
    {
        friend class LinkedList;
    private:
        int _value; /* data, can be any data type, but use integer for easiness */
        Node *_pNext; /* pointer to the next node */    
    public:
        /* Constructors with No Arguments */
        Node(void)
        : _pNext(NULL)
        { }    
        /* Constructors with a given value */
        Node(int val)
        : _value(val), _pNext(NULL)
        { }    
        /* Constructors with a given value and a link of the next node */
        Node(int val, Node* next)
        : _value(val), _pNext(next)
        {}    
        /* Getters */
        int getValue(void)
        { return _value; }    
        Node* getNext(void)
        { return _pNext; }
        };
    /* definition of the linked list class */
    class LinkedList
    {
    private:
        /* pointer of head node */
        Node *_pHead;
        /* pointer of tail node */
        Node *_pTail;
        
    public:
        /* Constructors with a given value of a list node */
        LinkedList(int val);
        /* Destructor */
        ~LinkedList(void);
        
        /* Function to a};

    /* definition of the linked list class */
    class LinkedList
    {
    private:
        /* pointer of head node */
        Node *_pHead;
        /* pointer of tail node */
        Node *_pTail;
        
    public:ppend a node to the end of a linked list */
        void tailAppend(int val);
        /* Function to reverse the list */
        void reverse();
        
        /* Traversing the list and printing the value of each node */
        void traverse_and_print();
    };

    LinkedList::LinkedList(int val)
    {
        /* Create a new node, acting as both the head and tail node */
        _pHead = new Node(val);
        _pTail = _pHead;
    }

    LinkedList::~LinkedList()
    {
        /*
         * Leave it empty temporarily.
         * It will be described in detail in the example "How to delete a linkedlist".
         */
    }

    void LinkedList::tailAppend(int val)
    {
        /* The list is empty? */
        if (_pHead == NULL) {
            /* the same to create a new list with a given value */
            _pTail = _pHead = new Node(val);
        }
        else
         {
            /* Append the new node to the tail */
            _pTail->_pNext = new Node(val);
            /* Update the tail pointer */
            _pTail = _pTail->_pNext;
        }
    }

    void LinkedList::reverse()
    {
        Node *pTempHead = _pHead, *pRestNodes = NULL, *pNextNode = NULL;
        /* The list is empty? do nothing */
        if (_pHead == NULL)
            return;
        /* The previous head node will act as the tail node after reversing */
        _pTail = _pHead;
        /* Take out the head node and make the reverse list basing on it */
        pRestNodes = _pHead->_pNext;
        
        while (pRestNodes != NULL) {
            /* Step1: Take out the next node */
            pNextNode = pRestNodes;
            /* Step2: Update the pointer of rest nodes after taking out the first */
            pRestNodes = pRestNodes->_pNext;
            /* Step3: Add the taken out node to the new list */
            pNextNode->_pNext = pTempHead;
            /* Step4: Update the new temp head node */
            pTempHead = pNextNode;
            /* Repeat Step 1-4 */
        }
        _pHead = pTempHead;
        _pTail->_pNext = NULL;
    }

    void LinkedList::traverse_and_print()
    {
        Node *p = _pHead;    
        /* The list is empty? */
        if (_pHead == NULL) {
            cout << "The list is empty" << endl;
            return;
        }    
        cout << "LinkedList: ";
        /* A basic way of traversing a linked list */
        while (p != NULL) { /* while there are some more nodes left */
            /* output the value */
            cout << p->_value << " ";
            /* The pointer moves along to the next one */
            p = p->_pNext;
        }
        cout << endl;
    }
    int main(int argc, const char * argv[])
    {
        /* Create a list with only one node */
        LinkedList list(1);
        /* Append 3 nodes to the end of the list */
        list.tailAppend(2);
        list.tailAppend(3);
        list.tailAppend(4);    
        cout << "Before reversing:" << endl;
        getch();
        }
    Tags:

    Virtusa 

  • 34. Write a program to implement the stack and queue using list

    Input : ,   Output :

    View Answer View Answer | Program Topics Linked List | Write Your Program Discuss in Forum | Add to Reading List To Reading List | Tag to companies Asked In | Level Fresher
  • Answer In: C   C++  
     
    #include<conio.h>       
    #include<iostream.h> 
    #include<process.h>  
    #include<malloc.h>   
    /*Creating a NODE Structure*/
    struct node
    {
       int data;
       struct node *next;
    };
     
    /*Creating a class QUEUE*/
    class queue
    {
       struct node *frnt,*rear;
       public:
          queue() // constructure
          {
         frnt=rear=NULL;
          }
          void insert(); /*to insert an element*/
          void del();  /* to delete an element*/
          void show(); /* to show the stack*/
    };
    /* Insertion */
    void queue::insert()
    {
       int value;
       struct node *ptr;
       cout<<"\nInsertion\n";
       cout<<"Enter a number to insert: ";
       cin>>value;
       ptr=new node;
       ptr->data=value;
       ptr->next=NULL;
       if(frnt==NULL)
          frnt=ptr;
       else
          rear->next=ptr;
       rear=ptr;
       cout<<"\nNew item is inserted to the Queue!!!";
       getch();
    }
     
    /* Deletion*/
    void queue::del()
    {
       if(frnt==NULL)
       {
          cout<<"\nQueue is empty!!";
          getch();
          return;
       }
       struct node *temp;
       temp=frnt;
       frnt=frnt->next;
       cout<<"\nDeletion Operation........\nDeleted value is "<<temp->data;
       delete temp;
       getch();
    }
     
    /* Show Queue*/
    void queue::show()
    {
       struct node *ptr1=frnt;
       if(frnt==NULL)
       {
          cout<<"The Queue is empty!!";
          getch();
          return;
       }
       cout<<"\nThe Queue is\n";
       while(ptr1!=NULL)
       {
          cout<<ptr1->data<<" ->";
          ptr1=ptr1->next;
       }
       cout<<"END";
       getch();
    }
    int main()
    {
       clrscr();
       queue q;
       int choice;
       while(1)
       {
          cout<<"\n-----------------------------------------------------------";
          cout<<"\n\t\tQUEUE USING LINKED LIST\n\n";
          cout<<"1:INSERTION\n2:DELETION\n3:DISPLAY QUEUE\n4:EXIT";
          cout<<"\nEnter your choice(1-4): ";
          cin>>choice;
          switch(choice)
          {
           case 1:
          q.insert();
          break;
           case 2:
          q.del();
          break;
           case 3:
          q.show();
          break;
           case 4:
          exit(0);
          break;
           default:
          cout<<"Please enter correct choice(1-4)!!";
          getch();
          break;
           }
       }
       return 0;
    }
    Tags:

    Virtusa 

  • 35. Write a program to compute the quicksort for the given input array

    Input : ,   Output :

  • Answer In: C   C++   PHP  
     
    <!DOCTYPE html>
    <html>
    <body>

    <?php 
    $unsorted 
    = array(43,21,2,1,9,24,2,99,23,8,7,114,92,5);

    function 
    quick_sort($array)
    {
        
    // find array size
        
    $length count($array);
        
        
    // base case test, if array of length 0 then just return array to caller
        
    if($length <= 1){
            return 
    $array;
        }
        else{
        
            
    // select an item to act as our pivot point, since list is unsorted first position is easiest
            
    $pivot $array[0];
            
            
    // declare our two arrays to act as partitions
            
    $left $right = array();
            
            
    // loop and compare each item in the array to the pivot value, place item in appropriate partition
            
    for($i 1$i count($array); $i++)
            {
                if(
    $array[$i] < $pivot){
                    
    $left[] = $array[$i];
                }
                else{
                    
    $right[] = $array[$i];
                }
            }
            
            
    // use recursion to now sort the left and right lists
            
    return array_merge(quick_sort($left), array($pivot), quick_sort($right));
        }
    }

    $sorted quick_sort($unsorted);
    print_r($sorted);

    ?>  

    </body>
    </html>
    Tags:

    No Tags on this question yet!

  • 36. Write a program to compute the bubble sort for the given input array

    Input : ,   Output :

  • Answer In: C   C++   PHP  
     
    #include<conio.h>
    
    #include<iostream.h>
    template<class bubble>
    void bubble(bubble a[], int n)
    {
        int i, j;
        for(i=0;i<n-1;i++)
        {
            for(j=i+1;j<n;j++)
            {
                if(a[i]>a[j])
                {
                    bubble element;
                    element = a[i];
                    a[i] = a[j];
                    a[j] = element;
                }
            }
        }
    }
     
    void main()
    {
        int a[6]={1,2,3,4,4,3};
        char b[4]={'s','b','d','e'};
        clrscr();
        bubble(a,6);
        cout<<"\nSorted Order Integers: ";
        for(int i=0;i<6;i++)
            cout<<a[i]<<"\t";
        bubble(b,4);
     
        cout<<"\nSorted Order Characters: ";
        for(int j=0;j<4;j++)
            cout<<b[j]<<"\t";
        getch();
    }
    Tags:

    No Tags on this question yet!

  • 37. Write a program to construct the binary search tree

    Input : ,   Output :

  • Answer In: C  
     
    #include <stdio.h>
    #include <stdlib.h>
    struct btnode
    {
        int value;
        struct btnode *l;
        struct btnode *r;
    }*root = NULL, *temp = NULL, *t2, *t1;
     void create();
     void insert();
     int flag = 1;
     void main()
    {
    insert();
    getch();
    }
    /* To insert a node in the tree */
    void insert()
    {
        create();
        if (root == NULL) 
            root = temp;
        else    
            search(root);    
    }
     
    /* To create a node */
    void create()
    {
        int data;
     
        printf("Enter data of node to be inserted : ");
        scanf("%d", &data);
        temp = (struct btnode *)malloc(1*sizeof(struct btnode));
        temp->value = data;
        temp->l = temp->r = NULL;
    }
    Tags:

    No Tags on this question yet!

  • 38. Write a program to delete the given element in the tree

    Input : ,   Output :

  • Answer In: C  
     
    #include <stdio.h>
    #include <stdlib.h>
     
    struct btnode
    {
        int value;
        struct btnode *l;
        struct btnode *r;
    }*root = NULL, *temp = NULL, *t2, *t1;
     void create();
     void insert();
     void delete();
     int flag = 1;
     void main()
    {
     insert();
     delete();
    getch();
    }
    /* To insert a node in the tree */
    void insert()
    {
        create();
        if (root == NULL) 
            root = temp;
        else    
            search(root);    
    }
    Tags:

    No Tags on this question yet!

  • 39. Write a program to compute the sum of all elements in the tree

    Input : ,   Output :

  • Answer In: C  
     
    #include <stdio.h>
    #include <malloc.h>
     
    /* Structure to create the binary tree */
    struct btnode
    {
        int value;
        struct btnode *l;
        struct btnode *r;
    };
    struct btnode *root = NULL;
    int sum;
     
    /* Function Prototypes */
     
    void in_order_traversal(struct btnode *);
    void in_order_sum(struct btnode *);
    struct btnode *newnode(int);
     
    void main()

     
        /* Inserting elements in the binary tree */
        root = newnode(50);
        root->l = newnode(20);
        root->r = newnode(30);
        root->l->l = newnode(70);
        root->l->r = newnode(80);
        root->l->l->l = newnode(10);
        root->l->l->r = newnode(40);
        root->l->r->r = newnode(60);
        printf("The elements of Binary tree are:");
        in_order_traversal(root);
        in_order_sum(root);
        printf("\nThe sum of all the elements are:%d", sum);
    }
     
    /* Code to dynamically create new nodes */
    struct btnode* newnode(int value)
    {
        struct btnode *temp = (struct btnode *)malloc(sizeof(struct btnode));
        temp->value = value;
        temp->l = NULL;
        temp->r = NULL;
        return temp;
    }
     
    /* Code to display the elements of the binary tree */
    void in_order_traversal(struct btnode *p)
    {
        if (!p)
        {
            return;
        }
        in_order_traversal(p->l);
        printf("%d->",  p->value);
        in_order_traversal(p->r);
    }
     
    /* Code to find the sum of all elements in the tree */
    void in_order_sum(struct btnode *p)
    {
        if (!p)
        {
            return;
        }
        in_order_sum(p->l);
        sum = sum + p->value;
        in_order_sum(p->r);
    }
    Tags:

    No Tags on this question yet!

  • 40. Write a program to find the maximum and minimum depth of the tree

    Input : ,   Output :

  • Answer In: C  
     
    #include<stdio.h>
    
    #include<stdlib.h>
     
     
    /* A binary tree node has data, pointer to left child 
       and a pointer to right child */
    struct node 
    {
        int data;
        struct node* left;
        struct node* right;
    };
     
    /* Compute the "maxDepth" of a tree -- the number of 
        nodes along the longest path from the root node 
        down to the farthest leaf node.*/
    int maxDepth(struct node* node) 
    {
       if (node==NULL) 
           return 0;
       else
       {
           /* compute the depth of each subtree */
           int lDepth = maxDepth(node->left);
           int rDepth = maxDepth(node->right);
     
           /* use the larger one */
           if (lDepth > rDepth) 
               return(lDepth+1);
           else return(rDepth+1);
       }

     
    /* Helper function that allocates a new node with the
       given data and NULL left and right pointers. */
    struct node* newNode(int data) 
    {
        struct node* node = (struct node*)
                                    malloc(sizeof(struct node));
        node->data = data;
        node->left = NULL;
        node->right = NULL;
       
        return(node);
    }
       
    int main()
    {
        struct node *root = newNode(1);
     
        root->left = newNode(2);
        root->right = newNode(3);
        root->left->left = newNode(4);
        root->left->right = newNode(5); 
       
        printf("Hight of tree is %d", maxDepth(root));
       
        getchar();
        return 0;
    }
    Tags:

    No Tags on this question yet!