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.

Please wait...

Programs Questions and Answers

Question :: 31
Write an efficient program to traverse the list N nodes from the tail

Input : NA

Output : NA

|  Linked List | | | |  Fresher
Answer In:

#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!

Question :: 32
Write a program insert an element into ascending order list

Input : NA

Output : NA

|  Linked List | | | |  Fresher
Answer In:

#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

Question :: 33
Write a program to reverse the single linked list

Input : NA

Output : NA

|  Linked List | | | |  Fresher
Answer In:

#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

Question :: 34
Write a program to implement the stack and queue using list

Input : NA

Output : NA

|  Linked List | | | |  Fresher
Answer In:

#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

Question :: 35
Write a program to compute the quicksort for the given input array

Input : NA

Output : NA

|  Sorting | | | |  Fresher
Answer In:

<!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!

Question :: 36
Write a program to compute the bubble sort for the given input array

Input : NA

Output : NA

|  Sorting | | | |  Fresher
Answer In:

#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!

Question :: 37
Write a program to construct the binary search tree

Input : NA

Output : NA

|  Trees | | | |  Fresher
Answer In:

#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!

Question :: 38
Write a program to delete the given element in the tree

Input : NA

Output : NA

|  Trees | | | |  Fresher
Answer In:

#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!

Question :: 39
Write a program to compute the sum of all elements in the tree

Input : NA

Output : NA

|  Trees | | | |  Fresher
Answer In:

#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!

Question :: 40
Write a program to find the maximum and minimum depth of the tree

Input : NA

Output : NA

|  Trees | | | |  Fresher
Answer In:

#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!