Skip to main content

Linked List data structure| Insertion at the end

Introduction:
In this tutorial, we will insert a new node at the end of the list.

To insert a new node at the end of the list, we have to follow few steps:

step1: first of all we should have a linked list, and if we don't have the list, then we have to create the list first.

code for creating the list:

#include<bits/stdc++.h>
using namespace std;

struct Node{
int val;
struct Node *next;

};

int main(){

    int n;
    cout<<"enter the number of Nodes:";
    cin>>n;
    struct Node* head = NULL;
    struct Node* temp;
    int m;
    while(n--){
        cout<<"enter the data into nodes:";
        cin>>m;
        if(head==NULL){
            head = new Node();//creating a node
            head->val = m; // assigning value
            head->next=NULL;
            temp=head;//updating temp
        }
        else{
        struct Node *temp1 = new Node();//creating a node
        temp1->val = m;//assigning value
        temp1->next = NULL;
        temp->next = temp1; // linking temp with newly created node(temp1)
        temp=temp1;// shifting temp to newly created node(temp1)
        }
    }
}

now we have our list.

step2: Now we have to reach at the last node of previously created list. and to reach the last node we simply run a while loop.

struct Node *temp = head;

while(temp->next != NULL){
temp=temp->next;
}

let's understand this part:

first of all i created temp variable and point it to head. this step is neccessary, because if we traverse it like
while(head->next!=NULL){
head=head->next;
}
by using this piece of code we will reach at the last node, but now head is pointing to the last node and we will lost all node before the last node of list, cause we know that head is always the first node of the list. so we have to maintain our head. that'a why we are using temp variable, after using temp variable head will be at the first node and temp will reach at the last node after execution of while loop.

one point we should keep in mind, in linked list "next" field of last node is always null.

till now we have created our list and reach at the end of the list and head is pointing to the first node of the list and temp is pointing to the last node of the list.



step3: now create a new node which we will insert at the end of the list.

struct Node *newNode = new Node();//new node is created
newNode->val = 5;
newNode->next=NULL;

now we have new node also.

final step: In this step we will link our new node to last node of the list(where the temp is).

we know temp is at last node, and to link new node to last node of the list we will simply put the address of new node into the last node of the list. and we know that information about last node is currrently in our temp variable.
temp->next = newnode.

this means we have put the address of newnode into the next field of last node of the list.

now we have a node linked with our list.



full code:

#include<bits/stdc++.h>
using namespace std;

struct Node{
int val;
struct Node *next;
};

int main(){

    int n;
    cout<<"enter the number of Nodes:";
    cin>>n;
    struct Node* head = NULL;
    struct Node* temp;
    int m;
    while(n--){
        cout<<"enter the data into nodes:";
        cin>>m;
        if(head==NULL){
            head = new Node();//creating a node
            head->val = m; // assigning value
            head->next=NULL;
            temp=head;//updating temp
        }
        else{
        struct Node *temp1 = new Node();//creating a node
        temp1->val = m;//assigning value
        temp1->next = NULL;
        temp->next = temp1; // linking temp with newly created node(temp1)
        temp=temp1;// shifting temp to newly created node(temp1)
        }
    }
struct Node *temp = head;

while(temp->next != NULL){
temp=temp->next;
}

struct Node* newNode = new Node();
newNode->val = 5;
newNode->next = NULL;

temp->next = newNode();

while(head!=NULL){
cout<<head->val<<" ";
head=head->next;
}

}



Comments

Post a Comment

Popular posts from this blog

Disjiont Set Union-Find Data Structure | Code In C++

 Introduction:  In this tutorial we are going to write full program of disjoint set union find advance data structure in c++.  Problem Description: Disjoint Set Union (DSU) is an advance data structure, which basically uses in graph algorithms to find cycles. Codes:  Method1: Brute Force #include<bits/stdc++.h> using namespace std; int find(int f,vector<int>&dsuf){     if(dsuf[f]==-1)         return f;     return find(dsuf[f],dsuf); } void union_op(int from, int to, vector<int>& dsuf){     dsuf[from]=to; } bool isCycle(vector<pair<int,int> >&edge_list, vector<int>&dsuf){     for(int i=0;i<edge_list.size();i++){         int parent1=find(edge_list[i].first,dsuf);         int parent2=find(edge_list[i].second,dsuf);         if(parent1==pare...
Post a Comment
Read more

Construct Binary Tree from preorder and inorder | Data Structure

Introduction: In this tutorial we are going to see how we can construct the binary tree from given preorder and inorder. Prerequisites: you should know about binary tree traversal and on paper you can draw binary tree from given preorder and inorder traversal. Inorder:left->root->right; Preorder:root->left->right; Problem Statement: we have given two arrays. one for preorder and another for inorder. by using these two array we have to built a binary tree. eg: preorder = [3,9,20,15,7] inorder = [9,3,15,20,7] solution: Solution: We will follow recursive approach to solve this question.let's discuss how we can solve it. Trick: In the given preorder the very first element will be the root of the tree. then we will find root element in inorder also. and we know in inorder traversal we have left part then root and then right part of the tree. by using preorder we can get the root of the main tree and by using inorder and root we can get the left part and right part of the...
Post a Comment
Read more

Target Sum | Backtracking Problem

Introduction: In this tutorial we are going to solve a problem "Target Sum" which is from leetcode. and believe me it's really a good problem to understand Backtracking(Recursion). and if you try to understand the problem as well as code you will get a clear picture of Backtracking. Problem Statement: Link To Problem You are given a list of non-negative integers, a1, a2, ..., an, and a target, S. Now you have 2 symbols + and - . For each integer, you should choose one from + and - as its new symbol. Find out how many ways to assign symbols to make sum of integers equal to target S. Input: nums is [1, 1, 1, 1, 1], S is 3. Output: 5 Explanation: -1+1+1+1+1 = 3 +1-1+1+1+1 = 3 +1+1-1+1+1 = 3 +1+1+1-1+1 = 3 +1+1+1+1-1 = 3 There are 5 ways to assign symbols to make the sum of nums be target 3. Solution: As given in question, we have two operation + and -. so we will make recursive call for + and - . and if we have sum as target and we have reached upto the last ind...
Post a Comment
Read more