0
What else can I help you with?
How many minimum node required for a B tree?
one node
What is node in network topology?
A node is a single workstation present in a computer networking, many node together when combined makes a network.
The group of conduction fibers carrying the impulse from the AV node?
Yay! Jeopardy!"What is the His-Purkinje fiber system, also known as "the bundle of His".
Write an iterative function to search an element in a binary search tree?
_node* search (_node* head, _key key) { _node* node; for (node=head; node != NULL;;) { if (key == node->key) return node; else if (key < node.>key) node = node->left; else node = node->right; } return node; }
What is node to node delivery?
Node to node delivery is a general networking reference and is often contrasted with end-to-end delivery. The terms apply equally well to delivering mail and sending data over over the Internet. It helps to have a specific example illustrating the meaning of "network" within the context of the reference to node-to-node, but the general idea is pretty universal. A network is normally made of of connections between many points. Any connection between two of those points without an intervening point is a node-to-node connection. If you are driving a delivery truck, the path between to stops is the node-to-node path and what comes from one stop to the next is a node-to-node delivery. Networks usually have nodes where things enter the network or leave it. If a delivery is to go from and entering point to a leaving point, it is an end-to-end delivery and may involve many or few intermediate node-to-node transportation transfers. Needless to say, there are may variations of nodes and connections and communication strategies in the various networks, so there is this vocabulary that is useful that is general for many types of networks.
If the degree of a node is 0 then the tree is called?
This would be just a single node, since no edges (you can think of degree as the number of edges connected to a node). If you are talking about the in-degree, or out-degree of a node being zero, this can happen many times in a directed graph (in-degree = # edges going IN to node, out-degree = # edges going out...).
How to Print data of all nodes of linked list?
for (node=head; node!=null; node=node->next) printnode(node);
How to find the mirror image of a binary tree?
Refer to http://cslibrary.stanford.edu/110/BinaryTrees.html void mirror(struct node* node) { if (node==NULL) { return; } else { struct node* temp; // do the subtrees mirror(node->left); mirror(node->right); // swap the pointers in this node temp = node->left; node->left = node->right; node->right = temp; } }
Can we use doubly linked list as a circular linked list?
Yes. The tail node's next node is the head node, while the head node's previous node is the tail node.
How many pointers will have to be changed if a node is deleted from a linear linked list?
For a singly-linked list, only one pointer must be changed. If the node about to be deleted (let's call it node for the sake of argument) is the head of the list, then the head node pointer must be changed to node->next. Otherwise, the node that comes before the deleted node must change its next pointer to node->next. Note that given a singly-linked node has no knowledge of its previous node, we must traverse the list from the head in order to locate that particular node, unless the node is the head of the list: void remove (List* list, Node* node) { if (!list !node) return; // sanity check!if (list->head == node) {list->head = node->next;} else {Node* prev = list->head;while (prev->next != node) prev = prev->next; // locate the node's previous nodeprev->next = node->next;}} Note that the remove function only removes the node from the list, it does not delete it. This allows us to restore the node to its original position, because the node itself was never modified (and thus still refers to its next node in the list). So long as we restore all removed nodes in the reverse order they were removed, we can easily restore the list. In order to delete a node completely, we simply remove it and then free it:void delete (List* list, Node* node) {if (!list !node) return; // sanity check!remove (list, node);free (node);} For a doubly-linked list, either two or four pointers must be changed. If the node about to be deleted is the head node, then the head node pointer must be changed to n->next and n->next->prev must be changed to NULL, otherwise, n->prev->next becomes n->next. In addition, if the node about to be deleted is the tail node, then the tail node pointer must be changed to n->prev and n->prev->next must be changed to NULL, otherwise, n->next->prev becomes n->prev. Deletion from a doubly-linked list is generally quicker than deletion from a singly linked list because a node in a doubly-linked list knows both its previous node and its next node, so there's no need to traverse the list to locate the previous node to the one being deleted. void remove (List* list, Node* node) {if (!list !node) return; // sanity check!if (list->head == node) {list->head = node->next;node->next->prev = NULL;} else {node->prev->next = node->next; }if (list->tail == node) {list->tail = node->prev;node->prev->next = NULL;} else {node->next->prev = node->prev; }} Again, to physically delete the node we simply remove and then free the node:void delete (List* list, Node* node) {if (!list !node) return; // sanity check!remove (list, node); free (node); }
Algoritm for deleting the last element from a list?
Given a list and a node to delete, use the following algorithm: // Are we deleting the head node? if (node == list.head) { // Yes -- assign its next node as the new head list.head = node.next } else // The node is not the head node { // Point to the head node prev = list.head // Traverse the list to locate the node that comes immediately before the one we want to delete while (prev.next != node) { prev = prev.next; } end while // Assign the node's next node to the previous node's next node prev.next = node.next; } end if // Before deleting the node, reset its next node node.next = null; // Now delete the node. delete node;
Is null node equal to leaf node?
No. A leaf node is a node that has no child nodes. A null node is a node pointer that points to the null address (address zero). Since a leaf node has no children, its child nodes are null nodes.
