0
What else can I help you with?
How do you copy only structure and not data?
To copy a structure you simply allocate the amount of memory required to store the structure. For simple data structures like arrays that's all you need to do (leaving the memory uninitialised or set to some default value such as zero). But for complex structures like lists, trees and graphs, you need to recreate the links between the nodes within the allocated memory. If the original structure is not allocated in contiguous memory, this can be more trouble than it is actually worth. A simpler approach would be to rebuild the structure one node at a time, using the node's default value for the data. This can be simplified further by separating the data from the structure, so that the structure simply refers to the data rather than stores the data.
Difference between in-degree and out-degree of a vertex in data structures?
In-degree is a count of the number of ties directed to the node, and out-degree is the number of ties that the node directs to others.
How is a File Allocation Table different from an inode?
1-the Fat must be saved totally in the Main memory,but only the I-node musst be saved in the main memory 2-with i-node faster searchind an accessing a data block 3-i-node area is only accesible by the Operating system
Write the concepts of linked list?
A simple linked list is built out of nodes. Each node consists of two sections, data and a pointer. The data contains whatever information that this node of your list needs to contain, and the pointer contains the memory address of the next node in your list.
What is the difference between sequential allocation and linked allocation in java?
Sequential allocation refers specifically to arrays. An array is, by definition, a contiguous block of memory. The index of the array is used as an offset from the memory address of the beginning of the array - this is why access to any element in an array takes a constant amount of time to compute. "Linked allocation" is best described by linked lists. These data structures are connected by a series of nodes. A node contains at least two pieces of information: some piece of data and a reference (link) to the next node in the chain. Since changing the position of a node in a linked list only requires changing references to other nodes, insertion and deletion is trivial. Note that these "referential" linked data structures are not the only way to link data, just the easiest to understand and implement.
What are pros and cons of message passing?
Advantages:Memory is scalable with the number of processors. Increase the number of processors and the size of memory increases proportionately.Each processor can rapidly access its own memory without interference and without the overhead incurred with trying to maintain global cache coherency.Cost effectiveness: can use commodity, off-the-shelf processors and networking.Disadvantages:The programmer is responsible for many of the details associated with data communication between processors.It may be difficult to map existing data structures, based on global memory, to this memory organization.Non-uniform memory access times - data residing on a remote node takes longer to access than node local data.source : https://computing.llnl.gov/tutorials/parallel_comp/#distributedmemory
What is branching factor in trees?
In computing, tree data structures, and game theory, the branching factor is the number of children at each node
What is the height of a specific node in a tree data structure?
The height of a specific node in a tree data structure is the number of edges on the longest path from that node to a leaf node.
What are primary data structure?
A primary data structure is a data structure that is created without the use of other data structures, whereas a secondary data structure relies on a primary data structure. A data structure is an organized collection of data elements.[NOTE: Be careful not to confuse the term data structure with the term data type. It is a common mistake. This answer addresses dat structures. Often people who ask about primary data structures or primitive data structures are really asking about primitve data types.]Here is an example where an array is a primary data structure and a binary tree is a secondary data structure based on the array:An array is a primary data structure -- it is a set of sequentially numbered data elements, such as an array of integers or an array of names -- name0, name, name2, ...A binary tree is a data structure where each element (called a node) has a data component and pointers to it's left and right sub-trees. [Think of a directory of folders, but each folder can only have two sub-folders.] We can create an and store an array of nodes to set up the tree in languages like C++ or Java.The root of the tree could be node 1 in the array, it would point to nodes 2 and 3. node 2 would point to nodes 4 and 5, while node 3 would point to nodes 6 and 7 .. and so on. generally node n point to nodes 2n and 2n+1. (You can start with node 0, but the math is a little easier if you start with node 1.)The binary tree in this case is the secondary data structure, while the undelying array is the primary data structure.
Write a c program to insert an element in the beginning at the end at the specified position in a linear linked list?
#include<stdio.h> #include<stdlib.h> typedef struct Node { int data; struct Node *next; }node; void insert(node *pointer, int data) { /* Iterate through the list till we encounter the last node.*/ while(pointer->next!=NULL) { pointer = pointer -> next; } /* Allocate memory for the new node and put data in it.*/ pointer->next = (node *)malloc(sizeof(node)); pointer = pointer->next; pointer->data = data; pointer->next = NULL; } int find(node *pointer, int key) { pointer = pointer -> next; //First node is dummy node. /* Iterate through the entire linked list and search for the key. */ while(pointer!=NULL) { if(pointer->data == key) //key is found. { return 1; } pointer = pointer -> next;//Search in the next node. } /*Key is not found */ return 0; } void delete(node *pointer, int data) { /* Go to the node for which the node next to it has to be deleted */ while(pointer->next!=NULL && (pointer->next)->data != data) { pointer = pointer -> next; } if(pointer->next==NULL) { printf("Element %d is not present in the list\n",data); return; } /* Now pointer points to a node and the node next to it has to be removed */ node *temp; temp = pointer -> next; /*temp points to the node which has to be removed*/ pointer->next = temp->next; /*We removed the node which is next to the pointer (which is also temp) */ free(temp); /* Beacuse we deleted the node, we no longer require the memory used for it . free() will deallocate the memory. */ return; } void print(node *pointer) { if(pointer==NULL) { return; } printf("%d ",pointer->data); print(pointer->next); } int main() { /* start always points to the first node of the linked list. temp is used to point to the last node of the linked list.*/ node *start,*temp; start = (node *)malloc(sizeof(node)); temp = start; temp -> next = NULL; /* Here in this code, we take the first node as a dummy node. The first node does not contain data, but it used because to avoid handling special cases in insert and delete functions. */ printf("1. Insert\n"); printf("2. Delete\n"); printf("3. Print\n"); printf("4. Find\n"); while(1) { int query; scanf("%d",&query); if(query==1) { int data; scanf("%d",&data); insert(start,data); } else if(query==2) { int data; scanf("%d",&data); delete(start,data); } else if(query==3) { printf("The list is "); print(start->next); printf("\n"); } else if(query==4) { int data; scanf("%d",&data); int status = find(start,data); if(status) { printf("Element Found\n"); } else { printf("Element Not Found\n"); } } } }
How to Print data of all nodes of linked list?
for (node=head; node!=null; node=node->next) printnode(node);
What is data structute?
A data structure is defined as a way of organizing all the data items that consider not only elements stored but also stores the relationship between those elements. this is of two types 1.Primitive 2.Non Primitive
