Skip to main content

Linked List Data Structure | Creation and Traversal

Introduction:
In this tutorial we will create our linked list.

Before writing code let's understand key words related to linked list:

1. Head:

   first node of the linked list is called the head of the list. and this node is most important.

2.Tail:
  
   last node is called the tail of the list which must points to  null.

    

     

step1:
For creating the list first of all let's declare the structure of Nodes of the list:

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

step2: write main function:

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)


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

the first while loop is used for creating the list, you can use for loop also like:
for(int i=1;i<=n;i++){}

and the second for loop is for traversing the created list.

so lets read our main function line by line.

first of all we are taking a variable "n". which is for how many nodes we want in our linked list.

after that we are initializing our Head to NULL. and also taking a temp variable to keep track of head.

now execute the while loop:

During iteration it will check either the head is NULL or not, if it is NULL then first of all create a node using "new" operator of c++. after creating the node push value of "m" into the head->val part and put NULL to head->next part. now temp will also point to the head after writing temp=head; now we can get value of head using temp also.

In the second iteration it will check head is NULL or Not, and this time head is not NULL, cause we have already created head in our previous iteration, so now what we will do is we will create a Node temp1, temp1->val = m and temp1->next=NULL, now main part comes.
we have created temp1. we have a temp variable as well as head. and currently temp is pointing to head. so what we will do is, we will link our temp1 to head (temp). to do this linking first of all we will make temp->next = temp1, it means in the next field of temp, now we have address of temp1. so now temp get linked with temp1 . now temp=temp1, it means we are shifting our temp to newly created node(temp1).
and this will happen until loop executed.

To traverse the list, we will simply run a while loop until head is not becoming NULL.
and after printing the value of head Node we are shifting it to the next node of the list and so on.

if you have any query, just comment your queries i will try to make it more clear.

next tutorial:



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

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

Group Anagrams solution with explanation:Leetcode solution

what is Anagrams? suppose we have two strings and the characters present in both of the strings are same. then both will be called anagram of each other. eg:" rat" and "art" both are anagram of each other. the characters present in both string are same. eg: "raat" and "art" these are not anagrams of each other. and the reason is that the frequency of "a" in "raat" is 2. while the frequency of "a" in "art" is 1. so these are not anagrams of each other. in short two strings will be anagram of each other if they have same characters and the count(frequency) of each and every character must be same in both strings. Solution: There are different ways to solve this question, so here we are going to use Hashmap to solve this question. cause whenever there is need to search we should go with the data structure which use balanced binary tress or hashing. and we know that Hashmap  uses balanced binary trees. so using...
Post a Comment
Read more