0
Presumably you are referring to the next unused element of an array. If your array contains unused elements then it is up to you, the programmer, to keep track of them. Typically you will do this by placing all unused elements at the end of the array. Knowing the array's overall capacity (in elements) and the number of elements that are currently in use, it is trivial to compute the address of the next free element; there is no need to maintain a separate pointer.
Perhaps you are referring to the (call) stack pointer. Call stacks are defined by the system. In 8086 architecture, the call stack is a fixed-length region of contiguous memory addresses allocated to a thread (every thread has its own call stack). The call stack extends downwards into lower memory addresses. The stack pointer (SP) register refers to the last element pushed onto the stack (the lowest used address). Note that it cannot possibly refer to the next unused element given that the length of an unused element cannot be determined until an element is actually pushed onto the stack. That is, if the element being pushed were 2 addresses (or bytes) in length, the SP will be decremented by 2 addresses and the new element will be placed at the new address. When we subsequently pop that element, the SP is simply incremented by 2 addresses.
Add your answer:
Earn +20 pts
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"); } } } }
What are the basic types of link list in java?
linear circular double linked linear double linked circular Knowing the names does not help much when your teacher will require you to actually know what the names mean. Start reading. Programming requires lots of reading.
What is traversing arrays?
Traversing an array simply means visiting every element of the array exactly once. Pointers facilitates this job. A pointer is first created to contain the base address of the array thereby pointing the first element. As the pointer is incremented, it points to the very next element and so on till the last element is visited. Thus the elements are visited sequentially in the same order as they are stored in the array.
Role of instruction pointer in 8086?
Its role is to point to the next instruction to be executed in the CPU. It always points to the next instruction to be executed in the CPU
How do you delete last element from link list?
void delete_last (node **head) { node *tmp = *head; node *prev = NULL; if (!tmp) { } else if (!tmp->next) { free(tmp); *head = NULL; } else { while (tmp->next) { prev = tmp; tmp = tmp->next; } prev->next = NULL; free(tmp); } return; }
What is list?
Each element has a pointer to the next element, except for the last one.
What is singling?
Each element has a pointer to the next element, except for the last one.
What is single list?
Each element has a pointer to the next element, except for the last one.
What is link list and type of link list?
A linked list is a set of elements, usually structures, where each element contains a pointer or index to the "next" element, along with the data represented by the element.Often, the elements are allocated from the heap. Sometimes, a fixed number of elements is contained in an array. In the first case, pointers are used. In the second case, indices are used.Types of linked lists are ... In an array implementation, read pointer as index.Singly linked - there is a head pointer, and one next pointer per element. The last element's pointer is null. This type of list can be traversed in only one direction.Doubly linked - there is a head pointer, and each element contains two pointers, one to the previous element and one to the next element. This type of list can be traversed in two directions, making insertion and deletion a bit easier, at the cost of extra memory.Circularly linked - the same as Singly or Doubly linked, except that the last element's pointer points back to the first element's pointer. These types of lists are often used as queues.
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"); } } } }
What are the basic types of link list in java?
linear circular double linked linear double linked circular Knowing the names does not help much when your teacher will require you to actually know what the names mean. Start reading. Programming requires lots of reading.
What is traversing arrays?
Traversing an array simply means visiting every element of the array exactly once. Pointers facilitates this job. A pointer is first created to contain the base address of the array thereby pointing the first element. As the pointer is incremented, it points to the very next element and so on till the last element is visited. Thus the elements are visited sequentially in the same order as they are stored in the array.
Definitions of single and double linked list?
A singly linked list has a single pointer in each element, pointing to the next element in the list. Travering the list can only be done in one direction. If you need to find the element prior to a certain element, you must traverse the list from the beginning, looking for an element with a next pointer that points to that certain element. A doubly linked list has two pointers in each element, pointing to the next and last elements in the list. Traversing the list can be done in two directions. The advantage of single is only one pointer, saving some space, while the disadvantage is ability to only traverse in one direction. The advantage of double is ability to traverse in both directions, while the disadvantage is the memory associated with the second pointer and the extra code and time used to update more pointers.
What is C implementation of queues?
It depends on the type of data, but generally you would just implement a data array and have a static pointer to the "next" element of the array and a static pointer to the "last" element of the array. New data would be added to the location of the "last" pointer. Data would be processed from the "next" pointer. Pointers would be incremented to the appropriate element whenever reading or writing and special attention given to any time you come to the end of the array.
Role of instruction pointer in 8086?
Its role is to point to the next instruction to be executed in the CPU. It always points to the next instruction to be executed in the CPU
How are the members in the linked list liked together?
Usually each member has a pointer storing the address of the next element.
What do you mean by pointer in linked list?
A pointer is a memory reference to a data structure. So when you allocate memory for your list elements, they will be stored at some address X in your system memory. A pointer is simply a variable that contains that address X. You can access the memory that a pointer points to by dereferrencing it with the * operator.Ex:int main(){LinkedList *x; /* Declare a pointer to a linked list (a type which you would have to define using "struct" or "class") */x = new LinkedList(); /* Here we create (aka "instantiate") a LinkedList object and allocate memory for it, x now contains (points to) the memory address of our LinkedList object */// You can now access any LinkedList members through x, for example x->next might point you to the next element of your LinkedList
