0
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.
Wiki User
∙ 11y ago
Add your answer:
Earn +20 pts
In networking what is hop to hop delivery of packets?
The Hop-to-hop delivery is also called the node-to-node delivery and it is the delivery between two nodes connected to the same network by a link and this jib is carried out by the data link layer....
What is difference between direct and indirect delivery?
Direct and Indirect DeliveryForwarded IP packets use at least one of two types of delivery based on whether the IP packet is forwarded to the final destination or whether it is forwarded to an IP router. These two types of delivery are known as direct and indirect delivery.Direct delivery occurs when the IP node (either the sending node or an IP router) forwards a packet to the final destination on a directly attached network. The IP node encapsulates the IP datagram in a frame format for the Network Interface layer (such as Ethernet or Token Ring) addressed to the destination's physical address.Indirect delivery occurs when the IP node (either the sending node or an IP router) forwards a packet to an intermediate node (an IP router) because the final destination is not on a directly attached network. The IP node encapsulates the IP datagram in a frame format, addressed to the IP router's physical address, for the Network Interface layer (such as Ethernet or Token Ring).IP routing is a combination of direct and indirect deliveries.In Figure 1.14, when sending packets to node B, node A performs a direct delivery. When sending packets to node C, node A performs an indirect delivery to Router 1. Router 1 performs an indirect delivery to Router 2. Router 2 performs a direct delivery to node C.
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; }
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.
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.
What is an intrathoracic node?
An intrathoracic node is a node within the chest cavity.
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); }
What is a simple node?
In computer programming, a simple node is a structure that holds two pointers. The first pointer refers to the data that is indirectly associated with the node, while the other refers to the next node in the sequence. Simple nodes are typically used in forward lists (singly-linked lists) where we keep track of the head node only. The last node in the list refers to NULL as there can be no next node after the last node. We can insert new data into the list knowing only the address of the data. A new node is constructed which then refers to the data and to the current head of the list. The new node then becomes the head of the list. Insertions at the head are performed in constant time. Inserting anywhere else in the list requires that we traverse the nodes recursively, following each node's next pointer, starting from the head, stopping at the node that should come after the new node. That node then becomes the new node's next node (if the node reaches the end of the list, the next node is NULL). Since we traversed recursively, we can return the newly inserted node to the caller, which can then be assigned to the caller's next node. All other recursions simply return the node we traversed to, thus leaving the caller's next node unchanged. The following example shows a simple node implementation for an ordered list of type int: typedef struct Node_t { // a simple node int* data; Node_t* next; } Node; Node* insert (int* data, Node* node) { // insert data if (!node *node->data > *data ) { // insertion point reached (end recursions) Node* pnode = malloc (sizeof (Node)); // create a new node pnode->data = data; // attach the data pnode->next = node; // refer to the next node (may be NULL) return pnode; // return the new node so the previous node can be updated } // if we get this far, the given node comes before the new data // delegate to the next node, the return value is the new or existing next node node->next = insert (data, node->next); return node; // return the node (it remains the previous node's next node) } void print_all (Node* node) { // print the given node and all that follow it while (node) { printf ("%d ", *node->data); node = node->next; } } Node* destroy_all (Node* node) // destroy the given node and all that follow it while (node) { Node* next = node->next; // refer to the next node (may be NULL) free (node->data); // release the current node's data free (node); // release the node itself node = next; // make the next node current (may be NULL) } return node; // always NULL } int main(void) { // The test program... srand ((unsigned) time (NULL)); // seed a random number generator Node* head = NULL; // the head node of the list (initially NULL for an empty list) for (int i=0; i<10; ++i) { // insert 10 random integers int* pint = malloc (sizeof (int)); // allocate a new integer on the free store if (!pint) break; // allocation failed, stop inserting! *pint = rand () % 10; // assign a random integer value (range 0:9) head = insert (pint, head); // insert the data (the return value is the new or existing head) } print_all (head); // print all the nodes starting from the head node head = delete_all (head); // destroy all the nodes starting from the head (returns NULL) return 0; }
What is Cardiopulmonary node?
cardiopulmonary node
