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.
Still curious? Ask our experts.
Chat with our AI personalities
Blake
Jordan
MaxineAdd 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; }
