GeekTech

What Is Cryptocurrency? Here Is Everything You Need To Know About Cryptocurrency

2021-07-09T00:02:00.007-07:00

What Is Cryptocurrency? Here Is Everything You Need To Know About Cryptocurrency

A cryptocurrency is a form of currency but the difference between cryptocurrency and a regular currency which we use in our daily lives is that the former is digital and decentralized. What has led to cryptocurrencies gaining attention from everywhere around is the fact that they can be stored and witness growth exponentially in value. This might be a surprise for many – well, there are not one, not two, not tens but thousands of cryptocurrencies. But some popular cryptocurrencies are Bitcoin, Ethereum, XRP, Cardano, Litecoin. Some of the cryptocurrencies are used instead of cash while some are used for private, direct transactions.

Cryptocurrencies work using a technology called the Blockchain. Blockchain is a decentralized technology spread across many computers that manage and records transactions. Part of the appeal of Blockchain is its security and assurance.

Learn More: What is Blockchain Technology?

Why invest in cryptocurrencies?

Cryptocurrencies are similar to stocks and real estate. While all can be traded in a centralized fashion, they are different in a few significant ways. Cryptocurrencies, such as Bitcoin, are decentralized. While this may seem like a negative, it actually makes the market more efficient and secure, as there is no one entity (government, company, or individual) controlling and controlling the price. Trading and holding cryptocurrency has some major advantages. First, there are no transaction fees. Transactions are very quick, very secure, and very cheap. It can be worth $0.01 to $0.02, making it a very easy decision to buy an extra $5 to $50 for yourself or to trade for a profit. Another common reason to invest in cryptocurrency is the desire for a reliable, long-term store of value. Unlike fiat money, most cryptocurrencies have a limited supply, capped by mathematical algorithms. This makes it impossible for any political body or government agency to dilute their value through inflation. Moreover, due to the cryptographic nature of cryptocurrencies, it is impossible for a government body to tax or confiscate tokens without the cooperation of the owner.

How to buy cryptocurrency

It’s important to note that there is no exchange that is 100% secure and 100% secure is also very hard to achieve. This is not to say that a trader should avoid using a reputable trading platform, but it is worth noting that a user’s identity and account credentials are always at risk. However, because cryptocurrencies are not regulated, the online exchanges you use to trade the various tokens are not required to use the most secure security practices. Here are some basic rules to follow when purchasing cryptocurrencies:

1. Choose an Exchange

There are lots of cryptocurrency exchanges. Due to decentralization and individual privacy, some exchanges even allow users to remain anonymous and do not require users to submit their personal information. Such kinds of exchanges operate autonomously and, typically, are decentralized which means they do not have an origin of control.

In today's scenario, however, the popular and renowned exchanges are not decentralized and they require KYC. In the United States, these exchanges include Coinbase, Gemini, Kraken. These exchanges have grown significantly over the last few years and in the number of benefits they offer.

2. Connect Your Exchange to a Payment Gateway

Once you have chosen an exchange, now you have to submit your personal documents. These documents may include a driver's license, social security number, as well as information about your employment or other sources of income. The information you submit may need can depend on the country/region you live in and the laws within it.

After the exchange verifies your documents and legitimacy you may now connect a payment option. At most exchanges, you can connect your bank account directly or you a debit or credit card.

3. Place an Order

After completing the above steps now you can buy Bitcoin and other cryptocurrencies. In recent years, cryptocurrency exchanges have slowly become more mainstream. They have grown exponentially in terms of liquidity and their breadth of features. The operational changes at cryptocurrency exchanges parallel the change in perception of cryptocurrencies. An industry that was once thought of as a scam or one with questionable practices is slowly growing into a legit one that has drawn interest from all the big players in the financial industry.

4. Store Cryptocurrency in Wallet

Cryptocurrency wallets are a special kind of wallet that stores your cryptocurrency more securely. Having your crypto in your personal wallet ensures that only you have control over the private key to your funds. It also gives you the ability to store funds away from an exchange and prevent the risk of your cryptocurrency or exchange getting hacked. Some Popular wallets are:

See Also: What is Cloud Computing?

How to Trade Cryptocurrency

How to Buy Cryptocurrency? How to buy Cryptocurrency with a credit card? How to buy Cryptocurrency without a credit card? How to Sell Cryptocurrency? The three main apps you will need are Coinbase (the most popular and easiest to use), BitGo (more secure, but more expensive), and Kraken Exchange (more user-friendly and cheap). Coinbase is by far the most popular and easiest to use exchange because it is one of the most popular and most used exchanges. Coinbase works directly with various banking institutions and exchanges to allow users to transfer money between their bank accounts, from their wallet to Coinbase, and to other exchanges. Coinbase also offers much more transparency, because you can see where all your money goes and what you’re investing in.

Should I buy cryptocurrency now?

So you are interested in buying cryptocurrency, and you are confused about when should you buy it? To be honest, it doesn't really matter - until and unless you're strategic about it.

The key to earning money in stocks is to buy strong investments and hold them for a long time of period. If the investments were really good, they should grow over time, and their prices will increase automatically.

The same principle is applied to cryptocurrency. If you think cryptocurrency has a bright future, it doesn't necessarily matter whether you buy when Bitcoin costs $60,000 or $30,000 per token. If it ends up reaching, say, $500,000 per token someday, you'll make a hefty profit regardless.

There is no guarantee that Bitcoin or any cryptocurrency will succeed. But if you're going to invest in them, it should be because you believe in their potential and are willing to hold your investments for the long term. If you're only investing to try to make a quick buck, then my friend it is risky you'll most likely end up losing more than you earn.

Conclusion

A new day has arrived and with that a new level of growth and awareness within the Bitcoin and cryptocurrency community. In the last few years, cryptocurrencies have grown at an exponential rate and have reached a tipping point in the industry. But it does not mean that if you buy cryptocurrency you will be Bill Gates or Jeff Bezos in a year or two. You need to be patient and you should invest in cryptocurrency if and only if you have the potential to hold your investments for the long term.

Please share your thoughts about cryptocurrency below!!

Want to learn more about Technology and Programming? Check out this amazing blog."

Program to Reverse a Queue - Code Explained

2020-09-30T06:54:00.002-07:00

Today we will be discussing the Program to Reverse a Queue - Code Explained. But before reading further if you are unfamiliar with the concept of queue then refer to this link. Suppose we have a queue 1->2->3->4 then after reversing it should look like 4->3->2->1. Now let's discuss the procedure:

Procedure

1. First we will make a queue and insert some values in it (data structures types).

2. Now make a function to reverse the queue. In that function we will iterate the list from the rear until we reach the front of the queue.

3. This will print the queue in reverse order.

Code

  
    #include<iostream>
using namespace std;

class Queue
{
	private:
		int front;
		int rear;
		int a[];
		int size;
	public:
		Queue(int s)   //constructor to set size of array
		{
			size=s;
			front=-1;
			rear=-1;
		}
		
		int empty()   //checks if queue is empty or not
		{
			if(front==-1 && rear==-1)
			   return 1;
			else
			   return 0;
		}
		
		int full()    //checks if queue is full or not
		{
			if(rear==size-1)
			  return 1;
			else
			  return 0;
		}
		
		void enqueue(int data)  //insert data in queue
		{
			if(empty())
			{
				front=rear=0;
			}
			if(full())
			{
				return;
			}
			else
			{
				rear=rear+1;
			}
			a[rear]=data;
		}
		
		
		void reverse()
		{
			for(int i=rear;i>=front+1;i--)
			{
				cout<<a[i]<<" ";
			}
		}
		
		void show()   //print data in the queue
		{
			for(int i=front+1;i<=rear;i++)
			{
				cout<<a[i]<<" ";
			}
			cout<<endl;
		}
};

int main()
{
	Queue q(7);
	q.enqueue(2);
	q.enqueue(3);
	q.enqueue(-4);
	q.enqueue(5);
	q.enqueue(-6);
	cout<<"data in queue: ";
	q.show();
	cout<<endl;
	cout<<"queue after reversing: ";
	q.reverse();
	return 0;
}

Explanation of code

1. First we will write a simple code of queue which will have:

Queue() : It is a constructor which will initialize the size of array, front and rear.
empty() : This function checks if the queue is empty or not.
full() : This function checks if the queue is full or not.
enqueue() : This function inserts the data in the queue.
show() : This function prints the queue.

2. Insert some values in the queue. (data structures types)

3. Now we have created a function named reverse() to Program to Reverse a Queue - Code Explained .

4. In the reverse() we have written a for loop which starts from rear of the queue and prints the values of the queue until it reaches the front of the queue.

for(int i=rear;i>=front+1;i--)
{
cout<<a[i]<<" ";
}

** This was the Program to Reverse a Queue - Code Explained. I hope you have understood the logic.

Rest API - Explained in an Easy, Quick and Simple Way

2020-09-23T07:47:00.006-07:00

Hey Developer, how long have you been in your Computer Science profession ? Nevermind, but have you ever heard of Rest API's? I'm sure you have no matter what language you use. But do you know what are these rest API's ? Don't worry today we'll be discussing about Rest API - Explained in an Easy, Quick and Simple Way. Oh, and do tell me how long have you been in this coding profession in the comment section below 🙌.

Rest API

Let me explain with the help of an example. Suppose you want to make a weather application. Now in a weather app you can see that different locations have different temperatures and that temperature changes every now and then.

So, how to we get such huge amount of data from?

For that we have servers or clouds located around the globe. So when you use the weather app and try to search for weather of a location you will send a Request to the server that you want the temperature of XYZ location and then the server will Respond to your query.

But then how do you generate that data from server?

For that you will have to use a servlet. So now a client will send you the data and the servlet will respond you with the data.

But what will the servlet return to the client?

The servlet will return you the data in form of XML or JSON format (based on your requirement). But to get data from servlet you will have to write some bulky code and to make remove this bulky code we use Rest API. So what if you just have to create an object at server side and return the values associated with it or we can say you want to return just the state of the object.

Now whenever we use internet we use CURD operations ( C-Create U-Update R-Read D-Delete) . We CREATE the resource we UPDATE the resource we READ the resource and we DELETE the resource. So to perform these CURD operations we use Http methods like POST, GET, PUT,DELETE. So by using these operations we can perform a CURD operation. And that's how the Rest API works.

Use below Code to embed this Infographic:

This was all about the basics of Rest API. I hope you enjoyed reading.

What is Docker ? Explained in an Easy, Quick and Simple Way

2020-09-16T07:22:00.002-07:00

Have you heard of Docker? Do you know what it is or why it is used? Don't worry, Today you'll learn about What is Docker ? Explained in an Easy, Quick and Simple Way. So let's start:

What is the problem that Docker resolves?

There is a major problem that almost all developers face which is that whenever you build a project ( here we are talking about large-scale projects) it works absolutely fine on your machine but as soon as you move that project into your friend's computer or onto the server then the working or performance or optimization of your project decreases. Some uncertainties are like maybe your images are not loading correctly or there are glitches in the workflow of the project. So, in layman terms "the code works on my machine". So Docker was made to resolve this problem of "the code works on my machine".

Docker

Docker allows you to wrap up your code in containers which are portable. Now if you place that container on any platform maybe on a server or a friend's PC these containers make sure that the code inside it works exactly the same as if it were to run on your machine. So these containers are the heart of Docker. A docker container can store your code, configurations, dependencies, networking information or even the processes that you are running.

So to summarize Docker:

It is a client side application. So you can just install it and perform all kind of operations on the containers and move these containers anywhere.
It also acts as a service and it can be deployed on any server so that you can take your container from that server and deploy on any platform. It can also acts as a social networking platform , you can share your docker image and whenever someone wants to start at given checkpoint the they can start from that point.
Docker is a company that manages all these things for you.

Some best Docker Tutorials

So, that was all and I hope the gist of Docker is clear to you now. Thanks for reading !!!

Delete all even nodes of a Circular Linked List

2020-09-08T07:36:00.003-07:00

Today we will discuss how to Delete all even nodes of a Circular Linked List. But if you are unfamiliar with the concepts of circular linked list then please refer to this link. Suppose we have a circular linked list like 1->2->3->4 and 4 points back to 1, then after deleting even numbered nodes the list should look like 1->3 and 3 pointing to 1. Here we have deleted the 2nd and 4th node. Now, let's discuss the procedure:

Procedure

1. First we will make a circular linked list. (data structures types)

2. Now a circular linked list can have even nodes or odd nodes in total.

3. So, we will divide our problem into 2 cases:

When the circular linked list has even number of nodes.
When the circular linked list has odd number of nodes.

4. When the list will have even number of nodes then we will delete even numbered node but in this case the last node will also be deleted so the second last node shall point to the first node now.

5. When the list will have odd number of nodes then the last node will also be odd numbered so no need to delete that node.

6. Now to know how to delete nodes go to the Explanation of code.

Code

#include<iostream>
using namespace std;
struct node
{
    int data;
    struct node* next;
};
struct node* head=NULL;

class linked
{

public:
    void insert(int x)
    {
        struct node* temp=new node();
        temp->data=x;
        temp->next=NULL;
        if(head==NULL)
        {
            head=temp;
        }
        else
        {
            struct node* temp1=head;
            while(temp1->next!=NULL)
            {
                temp1=temp1->next;
            }
            temp1->next=temp;

        }
    }

    void assignhead()
    {
        struct node* temp=head;
        while(temp->next!=NULL)
        {
            temp=temp->next;
        }
        temp->next=head;
    }


    void delete_even()
    {
        struct node* temp=head;
        int c=1;
        while(temp->next!=head)
        {
            c++;
            temp=temp->next;
        }
        temp=head;
        temp=temp->next;

        if(c%2==0)
        {
            struct node* temp1=head;
            int n=-1;
            while(temp->next!=head)
            {
                if(n==-1)
                {
                    temp1->next=temp->next;
                    temp1=temp1->next;
                }
                temp=temp->next;
                n=n*(-1);
            }
            temp1->next=head;
        }
        else if(c%2!=0)
        {
            struct node* temp1=head;
            int n=-1;
            while(temp->next!=head)
            {
                if(n==-1)
                {
                    temp1->next=temp->next;
                    temp1=temp1->next;
                }
                temp=temp->next;

                n=n*(-1);
            }
        }
        cout<<"List after deleting even-numbered nodes: ";
        disp();

    }


    void disp()
    {
        struct node* temp=head;
        cout<<temp->data<<" ";
        temp=temp->next;
        while(temp!=head)
        {
            cout<<temp->data<<" ";
            temp=temp->next;
        }
        cout<<endl;
    }
};

int main()
{
    linked l;
    l.insert(3);
    l.insert(5);
    l.insert(8);
    l.insert(1);
    l.insert(9);
    l.insert(0);
    l.insert(2);
    l.insert(5);
    l.assignhead();
    cout<<"original list: ";
    l.disp();
    l.delete_even();
    return 0;
}

Explanation of code

1. First we will write a simple code of circular linked list which will have 3 functions:

- insert() - which will insert elements in the circular linked list.
- assignhead() - to make a link between last and first node.
- disp() - which will display the circular linked list.

2. Insert some values in the circular linked list.

3. Now we have created a function named delete_even() to Delete all even nodes of a Circular Linked List.
4. First we have created a temp variable pointing to the head. Then we have created a int variable 'c' which is initialized to 1. This 'c' will be used to store the number of nodes in the circular linked list.
struct node* temp=head;
int c=1;
5. Then we have written a while loop which iterate the whole list and increment c in each iteration. This will give us the number of nodes present in our list. (data structures types)

   while(temp->next!=head)
{
c++;
temp=temp->next;
}
6. Now we have assigned temp to head again. And after that we have made temp point to the second node.
   temp=head;
temp=temp->next;
7. Now we have an if condition which will be executed if we have even number of nodes (i.e c%2==0).
  if(c%2==0)
{
---
}
8. Inside the if condition we have made another pointer to node variable temp1 which is initialized to head. Then we have declared 'n' which is initialized to -1.
  struct node* temp1=head;
int n=-1;
9. Then we have started a while loop which will iterate our circular linked list till be reach the last node.
  while(temp->next!=head)
{
---
}
10. Then we have used another if condition which checks if 'n' is equal to -1 or not. Basic idea of using 'n' is that 'n' will be -1 whenever our temp will point to an even numbered node. Since temp is initially pointing to the second node (refer to point 6) which is an even numbered node so this if condition will hold true and we will enter this if condition block. temp1 is pointing to the first node thus we have made temp1 to point to the next node of temp and then we have incremented temp1. So, temp1 will now be at 3rd node.
  if(n==-1)
{
temp1->next=temp->next;
temp1=temp1->next;
}
11. Then we have incremented temp to next node (i.e it will also point to the 3rd node) and n will now become 1.
  temp=temp->next;
n=n*(-1);
12. Now if you iterate again this while loop again then you will notice that n is not -1 now so we won't enter the if block and we actually didn't wanted to enter the if block because we are at an odd numbered node (3rd node). I hope you can make sense of it now.
13. After this while loop gets over the we have written made temp1 to point to the first node because in this case we had even number of nodes so after deleting all even number of nodes the last node will also be even so we will delete that too. But then the second last node shall point to the first node. In this case that second last node will be temp1. (data structures types)

temp1->next=head;
14. Next we have written another if condition which is for odd number of nodes. The complete logic will be same for odd number of nodes. Just one change will be there that the last node in this case will not be deleted because we have odd number of nodes so no need to write temp1->next=head;

Guys you can follow me here :

https://github.com/mayank171

https://www.linkedin.com/in/mayank-mewar-586090173/

Exchange First and Last nodes in Circular Linked List

2020-09-02T07:10:00.002-07:00

Today we will be discussing the algorithm to Exchange First and Last nodes in Circular Linked List . But, if you are unfamiliar with the concepts of circular linked list then refer to this link. Suppose we have circular linked list 1->2->3->4 and 4 points to 1. Then after swapping the first and last node the circular linked list will look like 4->2->3->1 and 1 points to 4. Now, let's discuss the procedure:

Procedure

1. First we will make a circular linked list.

2. Now we will make a variable which will point to the first node.

3. Then we will make another variable which will point to the last node.

4. At last, we will swap the data of these 2 variables.

Code

#include<iostream>
using namespace std;
struct node
{
    int data;
    struct node* next;
};
struct node* head=NULL;

class linked
{

public:
    void insert(int x)
    {
        struct node* temp=new node();
        temp->data=x;
        temp->next=NULL;
        if(head==NULL)
        {
            head=temp;
        }
        else
        {
            struct node* temp1=head;
            while(temp1->next!=NULL)
            {
                temp1=temp1->next;
            }
            temp1->next=temp;

        }
    }

    void assignhead()
    {
        struct node* temp=head;
        while(temp->next!=NULL)
        {
            temp=temp->next;
        }
        temp->next=head;
    }


    void Swap()
    {
        struct node* temp=head;
        struct node* temp1=head;
        while(temp1->next!=head)
        {
            temp1=temp1->next;
        }
        swap(temp1->data,temp->data);
    }

    void disp()
    {
        struct node* temp=head;
        cout<<temp->data<<" ";
        temp=temp->next;
        while(temp!=head)
        {
            cout<<temp->data<<" ";
            temp=temp->next;
        }
        cout<<endl;
    }
};

int main()
{
    linked l;
    l.insert(3);
    l.insert(5);
    l.insert(8);
    l.insert(1);
    l.insert(-2);
    l.insert(7);
    l.insert(-3);
    l.assignhead();
    l.disp();
    l.Swap();
    l.disp();
    return 0;
}


</form>

Explanation of code

1. First we will write a simple code of circular linked list which will have 3 functions:

- insert() - which will insert elements in the circular linked list.
- assignhead() - to make a link between last and first node.
- disp() - which will display the circular linked list.

2. Insert some values in the circular linked list.

3. Now we have created a function named Swap() to Exchange First and Last nodes in Circular Linked List.

4. First we have created a pointer to node variable temp which is initialized to head. So, temp is pointing to the first node.

struct node* temp=head;

5. Next, we have created another pointer to node variable temp1 which is also initialized to head. But, later on we will use temp1 to point to the last node of list.

struct node* temp1=head;

6. Now we are using a while loop to traverse the list till end. Focus on the test condition of while loop. We have written that we will traverse the list until the next of the temp1 points to head OR in other words we are traversing the list till the last node only. So, this condition will make temp1 point to the last node. Inside the while loop we are just moving to the next node.

while(temp1->next!=head)
{
temp1=temp1->next;
}

7. At last we have used the in-built swap() to swap the data of temp and temp1.

Delete a node at kth Position in Circular Linked List

2020-08-27T07:34:00.001-07:00

Today we will discuss how to delete a node at kth position in circular linked list. But if you are unfamiliar with the concepts of circular linked list then please refer to this link . Suppose you have a circular linked list 1->2->3->4 and 4 pointing to 1. Let k=2 then we have to delete the second node. After deletion the list should be 1->3->4 and 4 pointing to 1. Now, let's discuss the procedure:

Procedure

1. First we will make a circular linked list.

2. Then we will traverse the list until we reach the node which is just previous to the kth node.

3. Now we will update the pointer of this previous node with the address of the node next to kth node.

4. If the value of 'k' is 1 then we have to delete the first node. While doing so we will traverse till last node and then we will update the pointer of this node with the address of the node next to 1st node. But we will also have to update the head pointer because if the first node is deleted then second node will now be the first node.

Code

#include<iostream>
using namespace std;
struct node
{
    int data;
    struct node* next;
};
struct node* head=NULL;

class linked
{

public:
    void insert(int x)
    {
        struct node* temp=new node();
        temp->data=x;
        temp->next=NULL;
        if(head==NULL)
        {
            head=temp;
        }
        else
        {
            struct node* temp1=head;
            while(temp1->next!=NULL)
            {
                temp1=temp1->next;
            }
            temp1->next=temp;

        }
    }

    void assignhead()
    {
        struct node* temp=head;
        while(temp->next!=NULL)
        {
            temp=temp->next;
        }
        temp->next=head;
    }


    void Delete(int k)
    {
        if(k!=1)
        {
            struct node* temp=head;
            int c=1;
            while(c<k-1)
            {
                temp=temp->next;
                c++;
            }
            temp->next=temp->next->next;
        }
        else
        {
            struct node* temp=head;
            while(temp->next!=head)
            {
                temp=temp->next;
            }
            head=temp->next->next;
            temp->next=temp->next->next;
        }
    }

    void disp()
    {
        struct node* temp=head;
        cout<<temp->data<<" ";
        temp=temp->next;
        while(temp!=head)
        {
            cout<<temp->data<<" ";
            temp=temp->next;
        }
        cout<<endl;
    }
};

int main()
{
    linked l;
    l.insert(3);
    l.insert(5);
    l.insert(8);
    l.insert(1);
    l.insert(-2);
    l.insert(7);
    l.insert(-3);
    l.insert(11);
    l.insert(0);
    l.insert(6);
    l.assignhead();
    l.disp();
    int k;
    cout<<"enter position you want to delete: "<<endl;
    cin>>k;
    l.Delete(k);
    l.disp();
    return 0;
}

Explanation of code

1. First we will write a simple code of circular linked list which will have 3 functions:

- insert() - which will insert elements in the circular linked list.
- assignhead() - to make a link between last and first node.
- disp() - which will display the circular linked list.

2. Insert some values in the circular linked list.

3. Now we have created a function named Delete() to delete a node at kth the circular linked list. It has a parameter 'k' which tells us about the position of the node to be deleted.

4. First we have checked if 'k' is not equals to 1 because if we have divided out problem into 2 parts. If the node which is to be deleted is the first node or any other node.

5. If 'k' is not equal to 1 then we have created a pointer to node variable 'temp' which is pointing to head. We have also created a variable 'c' which is a counter to traverse the list till the node which is just previous to kth node.

if(k!=1)
{
struct node* temp=head;
int c=1;

---

}

6. Then we have created a while loop which will iterate the list till we reach the node which is just previous to kth node.

while(c<k-1)
{
temp=temp->next;
c++;
}

7. Then we have updated the next pointer of temp with the next pointer of the kth node because the node just previous to kth node shall point to the node which is next to the kth node. (kth node is not physically deleted from the list, we have just changed the pointers so that it shall not come in the output screen ).

temp->next=temp->next->next;

8. Now we have reached the else part which will be executed if k is equal to 1 or if we want to delete the first node.

9. We have again created a pointer to node variable 'temp' which is pointing to head.

else
{
struct node* temp=head;

---

}

10. Then we have created a while loop which will iterate the list till we reach the last node whose next pointer is pointing to the first node again.

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

11. Then we have updated the head and assigned it the address of the node next to first node.

head=temp->next->next;

12. Then we have updated the next pointer of temp with the address of the node next to kth node . (kth node is not physically deleted from the list, we have just changed the pointers so that it shall not come in the output screen ).

temp->next=temp->next->next;

Sort a Circular Linked List

2020-08-21T07:13:00.002-07:00

Today we will be discussing how to Sort a Circular Linked List. But if you are unfamiliar with the concepts of circular linked list then please refer to this link. Suppose we have a circular linked list like 4->3->2->1 and 1 is pointing again to 4 then the sorted list should be 1->2->3->4 . (data structures types)

Now let's discuss the procedure for sorting.

Procedure

1. First we will make a circular linked list.

2. Now we will be using bubble sort to sort the list.

3. We will be iterating from first node till the second last node. Then we making another iteration inside the first iteration itself which will traverse from the next node of the node at which the first iteration will be currently executing till the last node.

Code

#include<iostream>
using namespace std;
struct node
{
    int data;
    struct node* next;
};
struct node* head=NULL;

class linked
{

public:
    void insert(int x)
    {
        struct node* temp=new node();
        temp->data=x;
        temp->next=NULL;
        if(head==NULL)
        {
            head=temp;
        }
        else
        {
            struct node* temp1=head;
            while(temp1->next!=NULL)
            {
                temp1=temp1->next;
            }
            temp1->next=temp;

        }
    }

    void assignhead()
    {
        struct node* temp=head;
        while(temp->next!=NULL)
        {
            temp=temp->next;
        }
        temp->next=head;
    }


    void sort()
    {
        struct node* temp=head;
        while(temp->next!=head)
        {
            struct node* temp1=new node();
            temp1=temp->next;
            while(temp1!=head)
            {
                if(temp1->data<temp->data)
                {
                    swap(temp->data,temp1->data);
                }
                temp1=temp1->next;
            }
            temp=temp->next;
        }
    }

    void disp()
    {
        struct node* temp=head;
        cout<<temp->data<<" ";
        temp=temp->next;
        while(temp!=head)
        {
            cout<<temp->data<<" ";
            temp=temp->next;
        }
        cout<<endl;
    }
};

int main()
{
    linked l;
    l.insert(3);
    l.insert(5);
    l.insert(8);
    l.insert(1);
    l.insert(-2);
    l.insert(7);
    l.insert(-3);
    l.insert(11);
    l.insert(0);
    l.insert(6);
    l.assignhead();
    l.disp();
    l.sort();
    l.disp();
    return 0;
}

Explanation of code

1. First we will write a simple code of circular linked list which will have 3 functions:

- insert() - which will insert elements in the circular linked list.
- assignhead() - to make a link between last and first node.
- disp() - which will display the circular linked list.

2. Insert some values in the circular linked list.

3. Now we have created a function named sort() to sort the circular linked list.

4. Then we have made a pointer to node "temp" which is assigned to head.

struct node* temp=head;

5. Then we have started a while loop which will iterate from temp which is at head until it reaches the second last node. The loop will stop when temp's next pointer will be pointing to head and only last node will point to the head so the loop will execute until second last node because temp->next will be equal to head for the last node.

while(temp->next!=head)
{

....

}

6. Inside the while loop we have made another pointer to node called "temp1" . Then we have made temp1 to point to the next node of the temp. Each time when temp will be incremented then temp1 will always point to the next node of temp. (data structures types)

struct node* temp1=new node();
temp1=temp->next;

7. Then we have started the a while loop which will iterate temp1 till the last node.

while(temp1!=head)
{

...

}

8. Then we have checked the if condition if the data of temp will be greater then temp1 the we will swap the data .

if(temp1->data<temp->data)
{
swap(temp->data,temp1->data);
}

9. Then we have incremented temp1.

temp1=temp1->next;

10. At last we have incremented temp.

temp=temp->next;

(data structures types)

Reverse a Circular Linked List

2020-08-15T06:36:00.002-07:00

Today we will be discussing how to find reverse of a circular linked list. But, if are unfamiliar with the concepts of circular linked list then click on this link where I have explained everything about circular linked list from basic to advance. Suppose you have a circular linked list like 1->2->3->4->5 and 5 pointing to 1 again. then the reverse of this list will be 5->4->3->2->1 and then 1 pointing to 5 again. Let's see the procedure for reversing this kind of list:

Procedure

1. First we will make a circular linked list.

2. Now we will assign 3 pointers to the first 3 nodes of the list. Because, we have to reverse the links between 2 nodes and when we will reverse the link between 2 nodes then the node which is ahead will lose its link to the next node and we will not be able to go to the next node. SO that's why we need an extra pointer pointing ahead of current node.

Code

#include<iostream>
using namespace std;
struct node
{
    int data;
    struct node* next;
};
struct node* head=NULL;

class linked
{

public:
    void insert(int x)
    {
        struct node* temp=new node();
        temp->data=x;
        temp->next=NULL;
        if(head==NULL)
        {
            head=temp;
        }
        else
        {
            struct node* temp1=head;
            while(temp1->next!=NULL)
            {
                temp1=temp1->next;
            }
            temp1->next=temp;

        }
    }

    void assignhead()
    {
        struct node* temp=head;
        while(temp->next!=NULL)
        {
            temp=temp->next;
        }
        temp->next=head;
    }

    void reverse()
    {
        struct node* temp=head;
        struct node* prev=head;
        struct node* current=head;
        current=current->next;
        temp=temp->next->next;
        while(current!=head)
        {
            current->next=prev;
            prev=current;
            current=temp;
            temp=temp->next;
        }
        head=prev;
        current->next=head;
    }

    void disp()
    {
        struct node* temp=head;
        cout<<temp->data<<" ";
        temp=temp->next;
        while(temp!=head)
        {
            cout<<temp->data<<" ";
            temp=temp->next;
        }
        cout<<endl;
    }
};

int main()
{
    linked l;
    l.insert(3);
    l.insert(5);
    l.insert(8);
    l.insert(1);
    l.insert(-2);
    l.insert(7);
    l.insert(-3);
    l.insert(11);
    l.insert(0);
    l.insert(6);
    l.assignhead();
    l.disp();
    l.reverse();
    l.disp();
    return 0;
}

Explanation of Code

1. First we will write a simple code of circular linked list which will have 3 functions:

- insert() - which will insert elements in the circular linked list.
- assignhead() - to make a link between last and first node.
- disp() - which will display the circular linked list.

2. Insert some values in the doubly linked list.

3. Now we have created a function named reverse() for reverse the circular linked list.
4. First we have created 3 pointer to node.
struct node* temp=head;
struct node* prev=head;
struct node* current=head;

5. Then we have assigned current to the second node and temp to the third node of the list. prev will be pointing to first node only.

6. Now we have started a loop which will execute until we reach the head or iterate the list once.

while(current!=head)
{

......

}

7. Now we have assigned current->next to prev which means we have assigned the next node of current to prev.

current->next=prev;

8. Then we have moved prev to current , current to temp and then we have incremented temp.

prev=current;
current=temp;
temp=temp->next;

9. Then after the while loop we have assigned head to prev because head should now point to the last node after reversing .

head=prev;

10. At last we have assigned current->next to head because current will now be at the first node and we have assigned next of current to head because this node will now become the last node.

current->next=head;

What is Devops ? Explained in an Easy, Quick and Simple Way

2020-08-11T07:17:00.002-07:00

You Guys might have heard of Devops. Today we will be discussing What is Devops ? Explained in an Easy, Quick and Simple Way and we'll see if it is the right choice for you or not. Now if you search on Internet about what is devops then you will get thousands of results but i'm pretty sure that none of them gave you the exact definition of devops.

Devops - Definition

Devops is not a tool or a programming language. It is the process of taking your product (website or an app) from its construction till the production state. DevOps is a method which helps the development team as well as the operational teams to do things in sync without panicking.

The Development team is responsible for writing code for application. The Operational team is responsible for managing the server operations, security operation, backups.

DevOps is a philosophy in which the Development as well as the Operational team sits together and work in sync. Hence in this way the operational team can keep a check on development team and vica-versa. DevOps also focuses on the things to be automated so that the user does not have to do much and they can even while working with the application.

DevOps includes many tools such as Jenkins, Docker, Github, Vagrant and a lot more. So DevOps is not about learning a particular tool because it is moreover a mindset. So, if you want yourself to be called DevOps Engineer then learning any of the tools won't help you much because it is more about understanding what is happening in every phase of Software Development Cycle.

Now there are position for a DevOps manager in various companies. A DevOps manager is the person who has previous experience of merging the Development and Operational team and knows how to sync the 2 teams.

I hope now you have got the gist of DevOps. Thanks for reading !!!

How to Become A Full Stack Web Developer

2020-08-06T07:52:00.001-07:00

What is Full Stack Web Development? How to become a Full Stack Web Developer? How many programming languages does one need to know to become a full-Stack Web Developer? These are the most common question among the students or programmers who want to start with web development. In this article, I will be discussing everything from what Full Stack Development means to complete roadmap to become a Full Stack Web Developer.

What is Full Stack Development?

It refers to the development of both front-end (client-side) as well as the back-end (server-side) portions of a web application.

Use Below Code to Embed this Info-graphic

How to Become A Full Stack Web Developer?

First we need to understand Front-end Development and Back-end Development.

Front-end Development means how your website is laid out to users on both web browsers and mobile devices. A front-end Developer must have knowledge of HTML, CSS, and Javascript. HTML forms the structure of the website. CSS is for making the website look good to the users. Javascript adds more features that you can use in your website like hover effects, lighters.
Back-end Development handles the functionality of your website. A back-end developer must have knowledge of scripting languages like PHP or Ruby or Python. A back-end developer must be able to write code to receive data from user and manipulate it. A backend developer also needs to know about databases because data received from users must be stored somewhere. So backend developer must have knowledge of query languages like MySQL or MongoDB.

Learning Front-end Development and Backend Development is your first step to becoming a Full Stack Developer.

Now a vast variety of websites use on the Linux operating system. So a Full Stack Web developer must know how to work with Linux OS. If you want to learn Linux command the best platform will be Ubuntu Linux Commands. This will be your second step to become a Full Stack Web Developer.

Now you need to learn about Version Control Tools like GitHub, BeanStalk, or GitLab. If you want to know what is git or what is GitHub then you can refer to this video. This makes your entire workflow seamless. A Version Control System includes many tools which help you to record changes you made by keeping track of modifications made. This will be your final step to become a Full Stack Web Developer.

Best resources to become Full Stack Developer

To Learn HTML, CSS for free you can refer to these links:-

To learn javascript for Free you can refer to these links:-

To learn about Linux OS you can refer to these links:-

To learn Version Control Systems you can refer to these links:-

Reverse a Doubly Linked List

2020-07-31T07:26:00.000-07:00

Today we will be discussing how to reverse a doubly linked list. But if you are new to doubly linked list then please refer to this link where I have explained everything about doubly linked list from basic to advance.
Reversing a doubly linked list is a tricky problem which is asked in many interviews. In a doubly linked list every node has 2 pointers - one pointing to next node and the other one pointing to previous node. Many students forget the fact that doubly linked list is a special type of linked list which can be reversed much easier than a singly linked list.

Procedure

1. First we will make a linked list.

2. Then we just have to iterate the doubly linked list till the end but make sure to initialize the previous pointer of the first node to NULL because after reversing the list the first node will become the last node and last node must point to NULL.

3. When we reach the last node we assign head pointer the address of last node .

4. Now you can iterate the list from head and instead of using next pointer to iterate the list use previous pointer to iterate the list and you will get the list in reverse order.

Code

#include<iostream>
using namespace std;
struct node
{
    int data;
    struct node* next;
    struct node* prev;
};
struct node* head=NULL;

class linked
{
public:
    void insert(int x)
    {
        struct node* temp=new node();
        temp->data=x;
        temp->next=NULL;
        temp->prev=NULL;
        if(head==NULL)
        {
            head=temp;
        }
        else
        {
            struct node* temp1=head;
            while(temp1->next!=NULL)
            {
                temp1=temp1->next;
            }
            temp1->next =temp;
            temp->prev =temp1;
            temp->next=NULL;

        }
    }

    void reverse()
    {
        struct node* temp=head;
        temp->prev=NULL;
        while(temp->next!=NULL)
        {
            temp=temp->next;
        }
        head=temp;

        temp=head;
        cout<<"reversed doubly linked list: ";
        while(temp!=NULL)
        {
            cout<<temp->data<<" ";
            temp=temp->prev;
        }
        cout<<endl;
    }

    void disp()
    {
        struct node* temp=head;
        cout<<"original linked list: ";
        while(temp!=NULL)
        {
            cout<<temp->data<<" ";
            temp=temp->next;
        }
        cout<<endl;
    }
};

int main()
{
    linked l;
    l.insert(1);
    l.insert(2);
    l.insert(4);
    l.insert(5);
    l.insert(6);
    l.insert(8);
    l.insert(9);
    l.insert(18);
    l.disp();
    l.reverse();
    return 0;
}

Explanation of Code

1. First we will write a simple code of doubly linked list which will have 2 functions:

- insert() - which will insert elements in the doubly linked list.
- disp() - which will display the doubly linked list.

2. Insert some values in the doubly linked list.

3. Now we have created a function named reverse() for reverse the doubly linked list.

4. First we have created a pointer to node named temp initialized to head of the list.

5. Then we have initialized the previous of temp to NULL because after reversing the list this node will become the last node of the list so its prev should be initialized to NULL.

temp->prev=NULL;

6. Then have iterated the list till the last node.

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

7. Then we have assigned head pointer the address of temp because after reversing the list the last node will be the first node and first node's address is contained in head pointer.

head=temp;

8. Next we have printed the data of list but in the loop we have used prev pointer to access the next node because in a doubly list we have 2 pointers for every node so we can traverse it from both the ends.

while(temp!=NULL)
{
cout<<temp->data<<" ";
temp=temp->prev;
}

Find Pair with given sum in Doubly Linked List

2020-07-25T06:26:00.002-07:00

Today we will be discussing how to Find Pair of elements from doubly linked list with given sum. But if you are new to doubly linked list then please refer to this link where I have explained everything about doubly linked list. Suppose you have a doubly linked list like 1-2-3-4-5 and you have to find pair of elements which adds up to 5 then you should get the output as (1,4) and (2,3). Now let's discuss the procedure:

Procedure

1. First we will make a linked list.

2. Then we will iterate the list by using 2 loops.

3. Suppose the outer loop is run by a variable 'x' and inner loop is run by a variable 'y'.

4. Thus 'x' will start iterating from 1st node till 2nd last node of the list.

5. And 'y' will iterate from next node of 'x' till the last node of the list.

6. In this way each pair of node will be compared and we can easily find the pair of nodes with given sum.

Code

#include<iostream>
using namespace std;
struct node
{
    int data;
    struct node* next;
};
struct node* head=NULL;

class linked
{
public:
    void insert(int x)
    {
        struct node* temp=new node();
        temp->data=x;
        temp->next=NULL;
        if(head==NULL)
        {
            head=temp;
        }
        else
        {
            struct node* temp1=head;
            while(temp1->next!=NULL)
            {
                temp1=temp1->next;
            }
            temp1->next =temp;

        }
    }


    void sum(int s)
    {
        struct node* temp=head;
        while(temp->next!=NULL)
        {
            struct node* temp1=temp->next;
            while(temp1!=NULL)
            {
                if(temp->data + temp1->data ==s)
                {
                    cout<<"("<<temp->data<<","<<temp1->data<<")"<<endl;
                }
                temp1=temp1->next;
            }
            temp=temp->next;
        }

    }

    void disp()
    {
        struct node* temp=head;
        while(temp!=NULL)
        {
            cout<<temp->data<<" ";
            temp=temp->next;
        }
        cout<<endl;
    }
};

int main()
{
    linked l;
    l.insert(5);
    l.insert(3);
    l.insert(-4);
    l.insert(7);
    l.insert(-6);
    l.insert(0);
    l.insert(9);
    l.insert(18);
    l.disp();

    int s;
    cout<<"Enter sum that you want to find in the doubly linked list: ";
    cin>>s;
    l.sum(s);
    return 0;
}

Explanation of Code

1. First we will write a simple code of doubly linked list which will have 2 functions:

- insert() - which will insert elements in the doubly linked list.
- disp() - which will display the doubly linked list.

2. Insert some values in the doubly linked list.
3. Now we have created a function named sum() for find pair of nodes which adds up to given sum. It takes an argument 's' which contain desired sum we have to find.

4. Then we have created a pointer to node variable 'temp' which is initialized to head.

struct node* temp=head;

5. Then we have used a while loop to iterate temp from 1st node till 2nd last node of the list.

while(temp->next!=NULL)
{

----------

}

6. Now we have created another pointer to node which is temp1 and initialized it with next node of temp.

struct node* temp1=temp->next;

7. Next we have iterated temp1 till the end of the list.

while(temp1!=NULL)
{

-----------

}

8. Inside temp1 's while loop we have placed a if condition to check if the sum of data at temp and data at temp1 is equal to the sum 's' passed in the function.

if(temp->data + temp1->data ==s)
{

----------

}

9. If the sum of temp's data and temp1 's data is equal to s the we have printed the pair of nodes inside if condition.

cout<<"("<<temp->data<<","<<temp1->data<<")"<<endl;

10. Then we have incremented temp1.

temp1=temp1->next;

11. Outside this loop we have incremented temp.

temp=temp->next;

How to find Middle Element of Doubly Linked List?

2020-07-21T07:09:00.002-07:00

Today we will be discussing how to find middle element of doubly linked list. But if you are new to doubly linked list then please refer to this link where I have explained everything about linked lists. Suppose you have a doubly linked list like 1-2-3-4-5 then the middle of this list will be 3. So, let's discuss the procedure to solve this problem.

Procedure

1. First we will make a linked list.

2. Then we will count the number of nodes in the doubly linked list.

A list which will have even number of nodes will have 2 middle nodes at position 'n/2' and 'n/2+1' (n is number of nodes in a list).
A list which will have odd number of nodes will have 1 middle element only at position (n+1)/2 (n is number of nodes in a list).

3. Then depending on even or odd number of nodes we will iterate the list till the positions mentioned above and print the values.

Code

#include<iostream>
using namespace std;
struct node{

  int data;
  struct node* next;
  struct node* prev;

};
struct node* head=NULL;

class doubly
{
    public:
    void insert(int x)
    {
        struct node* temp=new node();
        temp->data=x;
        if(head==NULL)
        {
            head=temp;
            temp->prev=NULL;
            temp->next=NULL;
        }
        else
        {
            struct node* temp1=head;
            while(temp1->next!=NULL)
            {
                temp1=temp1->next;
            }
            temp->prev=temp1;
            temp1->next=temp;
            temp->next=NULL;
        }
    }

    void middle()
    {
        struct node* temp=head;
        int c=0;
        while(temp!=NULL)
        {
            c++;
            temp=temp->next;
        }

        temp=head;
        int p=1;
        if(c%2==0)
        {
            int mid=c/2;
            while(temp!=NULL)
            {
                if(p==mid)
                    break;
                p++;
                temp=temp->next;
            }
            cout<<temp->data<<" "<<temp->next->data<<endl;
        }
        else
        {
            int mid=(c+1)/2;
            while(temp!=NULL)
            {
                if(p==mid)
                    break;
                p++;
                temp=temp->next;
            }
            cout<<temp->data<<endl;
        }
    }

    void disp()
    {
        struct node* temp=head;
        while(temp!=NULL)
        {
            cout<<temp->data<<" ";
            temp=temp->next;
        }
    }
};

int main()
{
    doubly l;
    l.insert(3);
    l.insert(5);
    l.insert(1);
    l.insert(4);
    l.insert(8);
    l.insert(7);
    l.insert(0);
    l.insert(2);
    l.disp();
    cout<<endl;
    l.middle();
    return 0;
}

Explanation of Code (line by line)

1. First we will write a simple code of linked list which will have 2 functions:

- insert() - which will insert elements in the doubly linked list.
- disp() - which will display the doubly linked list.

2. Insert some values in the doubly linked list.
3. Now we have created a function named middle() which will print the middle element of doubly linked list.
4. First we have created a 'temp' which is pointer to node. Then we have created some other variables like 'c=0', 'mid', 'p=1'.
5. Then we have started a while loop to count number of nodes in the list. The number of nodes are stored in variable 'c'.
6. Then we have initialized temp to head.
7. Then there is an if condition which checks if c%2==0 or not i.e number of nodes in the list are even or not.
8. If the number of nodes in the list are even then we have stored the middle value c/2 in a variable mid.
9. Then we have started a while loop which will iterate till 'mid' in the list. If 'p' is equal to 'mid' then we will break out of the loop because we have reached the middle of the list. Otherwise we will increment p and temp.
   while(temp!=NULL)
{
if(p==mid)
break;
p++;
temp=temp->next;
}
10. Then we have printed the middle values. First we have printed temp->data which will display the first middle node the we have printed the second middle value by using temp->next->data which will point to the data part of the next of the first middle value.
11. If the number of nodes in the list are not even the they will be odd. So the next if condition where we have checked if c%2!=0 is for odd number of nodes.
12.  If the number of nodes in the list are odd then we have stored the middle value (c+1)/2 in a variable mid.
13. Then we have started a while loop which will iterate till 'mid' in the list. If 'p' is equal to 'mid' then we will break out of the loop because we have reached the middle of the list. Otherwise we will increment p and temp.
  while(temp!=NULL)
{
if(p==mid)
break;
p++;
temp=temp->next;
}
14. Then we have simply printed the value at mid by using temp->data which is the middle element.

You can follow me here if you are interested :

https://github.com/mayank171

https://www.linkedin.com/in/mayank-mewar-586090173/

Middle element of a Linked List

2020-07-16T05:42:00.000-07:00

Today we will be discussing the algorithm to print middle element of a linked list. If you are new to linked list data structure then please refer to this link where I have explained everything about linked list. Suppose you have a list like 1->4->2->8->5 then the middle element of this list will be 2. SO we will write a program which will do so but first let's discuss the procedure.

Procedure

1. First we will make a linked list.
2. Then we will count the number of nodes in this list.

A list which will have even number of nodes will have 2 middle nodes at position 'n/2' and 'n/2+1' (n is number of nodes in a list).
A list which will have odd number of nodes will have 1 middle element only at position (n+1)/2 (n is number of nodes in a list).

3. Then depending on even or odd number of nodes we will iterate the list till the positions mentioned above and print the values.

Code

#include<iostream>
using namespace std;
struct node
{
    int data;
    struct node* next;
};
struct node* head=NULL;

class linked
{
public:
    void insert(int x)
    {
        struct node* temp=new node();
        temp->data=x;
        temp->next=NULL;
        if(head==NULL)
        {
            head=temp;
        }
        else
        {
            struct node* temp1=head;
            while(temp1->next!=NULL)
            {
                temp1=temp1->next;
            }
            temp1->next =temp;

        }
    }


    void middle()
    {
        struct node* temp=head;
        int c=0;
        int mid1;
        int p=1;
        while(temp!=NULL)
        {
            temp=temp->next;
            c++;
        }
        temp=head;
        if(c%2==0)
        {
            mid1=c/2;
            while(temp!=NULL)
            {
                if(p==mid1)
                    break;
                p++;
                temp=temp->next;
            }
            cout<<"Middle values are "<<temp->data<<"and"<<temp->next->data<<endl;
        }
        else if(c%2!=0)
        {
            mid1=(c+1)/2;
            while(temp!=NULL)
            {
                if(p==mid1)
                    break;
                p++;
                temp=temp->next;
            }
            cout<<"Middle values are "<<temp->data<<endl;
        }
    }

    void disp()
    {
        struct node* temp=head;
        while(temp!=NULL)
        {
            cout<<temp->data<<" ";
            temp=temp->next;
        }
        cout<<endl;
    }
};

int main()
{
    linked l;
    l.insert(2);
    l.insert(5);
    l.insert(21);
    l.insert(46);
    l.insert(48);
    l.insert(54);
    l.insert(10);
    l.insert(6);
    l.insert(18);
    l.insert(-4);


    l.disp();
    l.middle();
    return 0;
}

Explanation of Code

1. First we will write a simple code of linked list which will have 2 functions:

- insert() - which will insert elements in the linked list.
- disp() - which will display the linked list.

2. Insert some values in the linked list.
3. Now we have created a function named middle() which will print the middle element of a linked list.
4. First we have created a 'temp' which is pointer to node. Then we have created some other variables like 'c=0', 'mid1', 'p=1'.
5. Then we have started a while loop to count number of nodes in the list. The number of nodes are stored in variable 'c'.
6. Then we have initialized temp to head.
7. Then there is an if condition which checks if c%2==0 or not i.e number of nodes in the list are even or not.
8. If the number of nodes in the list are even then we have stored the middle value c/2 in a variable mid1.
9. Then we have started a while loop which will iterate till 'mid1' in the list. If 'p' is equal to 'mid1' then we will break out of the loop because we have reached the middle of the list. Otherwise we will increment p and temp.
   while(temp!=NULL)
{
if(p==mid1)
break;
p++;
temp=temp->next;
}
10. Then we have printed the middle values. First we have printed temp->data which will display the first middle node the we have printed the second middle value by using temp->next->data which will point to the data part of the next of the first middle value.
11. If the number of nodes in the list are not even the they will be odd. So the next if condition where we have checked if c%2!=0 is for odd number of nodes.
12.  If the number of nodes in the list are odd then we have stored the middle value (c+1)/2 in a variable mid1.
13. Then we have started a while loop which will iterate till 'mid1' in the list. If 'p' is equal to 'mid1' then we will break out of the loop because we have reached the middle of the list. Otherwise we will increment p and temp.
  while(temp!=NULL)
{
if(p==mid1)
break;
p++;
temp=temp->next;
}
14. Then we have simply printed the value at mid1 by using temp->data which is the middle element.

Sorting of Linked List in Increasing Order

2020-07-11T06:17:00.002-07:00

Today we will be discussing how to sorting of linked list in increasing order. But if you are unfamiliar with linked list then refer to this link where I have explained you about linked list from basic to advance. Suppose we have a linked list 4->2->5->8->1 then after sorting it should look like 1->2->4->5->8. So, let's discuss the procedure to solve the problem.

Procedure

1. First we will make a linked list.

2. Now we have many sorting algorithms like bubble sort, insertion sort, selection sort etc. We will be using bubble sort for sorting our list.

3. Now I hope you guys know how bubble sort works in arrays. If you do not know then refer to this link .

4. We will use bubble to sort linked list in the similar way we use it to sort an array.

Code

#include<iostream>
using namespace std;
struct node
{
    int data;
    struct node* next;
};
struct node* head=NULL;

class linked
{
public:
    void insert(int x)
    {
        struct node* temp=new node();
        temp->data=x;
        temp->next=NULL;
        if(head==NULL)
        {
            head=temp;
        }
        else
        {
            struct node* temp1=head;
            while(temp1->next!=NULL)
            {
                temp1=temp1->next;
            }
            temp1->next =temp;

        }
    }


    void sort()
    {
        struct node* temp=head;

        while(temp->next!=NULL)
        {
            struct node* temp1=temp->next;
            while(temp1!=NULL)
            {
                if(temp->data > temp1->data)
                {
                    swap(temp->data,temp1->data);
                }
                temp1=temp1->next;
            }
            temp=temp->next;
        }
    }


    void disp()
    {
        struct node* temp=head;
        while(temp!=NULL)
        {
            cout<<temp->data<<" ";
            temp=temp->next;
        }
        cout<<endl;
    }
};

int main()
{
    linked l;
    l.insert(2);
    l.insert(5);
    l.insert(21);
    l.insert(46);
    l.insert(48);
    l.insert(54);
    l.insert(10);
    l.insert(6);
    l.insert(18);
    l.insert(-84);
    l.insert(90);
    l.insert(42);
    l.insert(81);
    l.insert(34);
    l.insert(-101);
    l.insert(6);
    l.insert(48);
    l.insert(54);
    l.insert(5);
    l.insert(-6);
    l.insert(8);
    l.insert(-54);
    l.insert(10);

    l.disp();
    l.sort();
    l.disp();
    return 0;
}

Explanation of Code

1. First we will write a simple code of linked list which will have 2 functions:

- insert() - which will insert elements in the linked list.
- disp() - which will display the linked list.

2. Insert some values in the linked list.
3. Now we have created a function named sort() for sorting of linked list in increasing order.
4. Then we have created 'temp' which is a pointer to node. It is initialized to head .
5. Now we have started a while loop for iterating the list. Remember we are iterating from first node till the second last node.
   while(temp->next!=NULL)
6. Then we have created a new 'temp1' which is another pointer to node. It is initialized to temp->next which means it will always point to the next node of temp .
  struct node* temp1=temp->next;
7. Now we are starting another loop from temp1 till the last node.
  while(temp1!=NULL)

SEE ALSO : The Ultimate Guide To Best Sorting Algorithms With Programs

8. Then we are comparing the data of 2 nodes adjacent to each other. If data of previous node is greater than the data of node ahead of it the we will swap the 2 nodes.
if(temp->data > temp1->data)
{
swap(temp->data,temp1->data);
}
9. Then we have incremented temp1 so that it can point to a new node.
temp1=temp1->next;
10. This loop will run until a node comes to its original position in a sorted list.
11. Then outside this loop we have incremented temp.
temp=temp->next;

See Also : Interesting facts about C Programming

If you guys want me to sort linked list using some other sorting algorithm then please comment below.

Swap a node with its previous node in a Linked List

2020-07-08T07:23:00.001-07:00

Today we will discuss how to swap a node with its previous node in a linked list. But, if you are new to linked lists then please refer to this link where I have explained everything about linked lists. So, let's start shall we?

Procedure

1. First we w 1. First we will make a linked list.
2. Then user will enter the position 'p' of the node which is to be swapped with its previous node. ill make a linked list.
2. Then user will enter the position 'p' of the node which is to be swapped with its previous node.

3. Then we will iterate the list till that position 'p-1' and then we will swap the data of the previous node and the node at position 'p'.

Code

#include<iostream>
using namespace std;
struct node
{
    int data;
    struct node* next;
};
struct node* head=NULL;

class linked
{
public:
    void insert(int x)
    {
        struct node* temp=new node();
        temp->data=x;
        temp->next=NULL;
        if(head==NULL)
        {
            head=temp;
        }
        else
        {
            struct node* temp1=head;
            while(temp1->next!=NULL)
            {
                temp1=temp1->next;
            }
            temp1->next =temp;

        }
    }


    void swap(int x)
    {
        struct node* temp=head;
        int c=1,t;
        if(x<=1)
            cout<<"exception";
        else
        {
            while(c<x-1)
            {
                temp=temp->next;
                c++;
            }
            t=temp->data;
            temp->data=temp->next->data;
            temp->next->data=t;
            disp();
        }
    }

    void disp()
    {
        struct node* temp=head;
        while(temp!=NULL)
        {
            cout<<temp->data<<" ";
            temp=temp->next;
        }
        cout<<endl;
    }
};

int main()
{
    linked l;
    l.insert(2);
    l.insert(5);
    l.insert(21);
    l.insert(46);
    l.insert(48);
    l.insert(54);
    l.insert(10);

    l.disp();
    int n;
    cout<<"enter position of node: ";
    cin>>n;
    l.swap(n);
    return 0;
}

Explanation of code(line by line)

1. First we will write a simple code of linked list which will have 2 functions:

- insert() - which will insert elements in the linked list.
- disp() - which will display the linked list.

2. Insert some values in the linked list.
3. Now we have created a function named swap() to swap a node with previous node in a linked list. It will take an argument 'x' which denotes the position of the node which is to be swapped with its previous node.

4. Then we have created variables:

temp - Which is a pointer to node. It is initialized to head.
c - It is a variable which will be used in iterating the list. It is initialized to 1.
t - It is another variable which will be helping us in swapping data.

5. Then there's a if condition. If x <=1 then we have printed the message "exception" because if x<=1 then there will be no previous node to x.

if(x<=1)
cout<<"exception";

6. Otherwise we will enter the else condition.

7. Then we have iterated the list till the node which contain the address of the previous node.

while(c<x-1)
{
temp=temp->next;
c++;
}

8. Then we have placed the data of the previous node in variable 't'.

t=temp->data;

9. Then we have placed the data of the node ahead of previous node in previous node.

temp->data=temp->next->data;

10. Then we have placed the data in 't' in the node ahead of previous node.

temp->next->data=t;

11. Then we have called the disp() which will display the list after swapping.

nth node from end of Linked List

2020-07-03T07:24:00.000-07:00

Today we will discuss how to find nth node from end of linked list. But, if you don't know what linked lists are then please refer to this post where I have explained everything about linked list. Let me explain you about the problem. Suppose we have a linked list 1->2->3->4->5 and we are asked to find 2th node from end, then the answer 2nd node from end would be 4. Now let's understand how to solve nth node from end of linked list problem.

Procedure

1. First we will make a linked list.
2. Then we will count number of nodes in the linked list.
3. Then we the following formulae to find the position of nth node from beginning.
Suppose the list is 1->2->3->4->5 and we have to find 2nd node from end. Then we can also say that we have to find the 4th node from beginning because 2nd node from end and 4th node from the beginning are the same. Now there's a formula you can use to find position of a node from beginning when its position is given from the end:-

position of node from beginning = number of nodes - position of node from end +1

4. Now that we have got the position of node from beginning so we can simply iterate till that position and print the output.

Code

#include<iostream>
using namespace std;
struct node
{
    int data;
    struct node* next;
};
struct node* head=NULL;

class linked
{
public:
    void insert(int x)
    {
        struct node* temp=new node();
        temp->data=x;
        temp->next=NULL;
        if(head==NULL)
        {
            head=temp;
        }
        else
        {
            struct node* temp1=head;
            while(temp1->next!=NULL)
            {
                temp1=temp1->next;
            }
            temp1->next =temp;
        }
    }

    void nthnodefromend(int x)
    {
         struct node* temp=head;
         int c=0;
         while(temp!=NULL)
         {
             temp=temp->next;
             c++;
         }
         c=c-x;
         temp=head;
         int t=1;
         while(t<=c)
         {
             temp=temp->next;
             t++;
         }
         cout<<x<<"th node from end is "<<temp->data<<endl;

    }

    void disp()
    {
        struct node* temp=head;
        while(temp!=NULL)
        {
            cout<<temp->data<<" ";
            temp=temp->next;
        }
        cout<<endl;
    }
};

int main()
{
    linked l;
    l.insert(2);
    l.insert(5);
    l.insert(21);
    l.insert(46);
    l.insert(48);
    l.insert(54);
    l.insert(10);

    l.disp();
    int n;
    cout<<"enter position of node from end to be searched: ";
    cin>>n;
    l.nthnodefromend(n);
    return 0;
}

Explanation of code(line by line)

1. First we will write a simple code of linked list which will have 2 functions:

- insert() - which will insert elements in the linked list.
- disp() - which will display the linked list.

2. Insert some values in the linked list.
3. Now we have created a function named nthnodefromend() to find nth node from end of a linked list. This function takes an argument 'x' which denotes the position of node we have to find from the end.
4. First we have created a pointer to node temp which is initialized with head and a variable 'c' which is initialized to 0. 'c' will store the number of nodes in the list.
struct node* temp=head;
int c=0;
5. Then we have started a while loop to count number of nodes in the list.
while(temp!=NULL)
{
temp=temp->next;
c++;
}
6. Then we have used the formula to find position of a node from beginning when the position from end is given:

position of node from beginning = number of nodes - position of node from end +1

c=c-x;

7. We have not added 1 to the above statement because a linked list starts its traversal from the first node itself.

8. Then we have initialized temp to head again and we have made another variable named t initialized to 1 which will be a counter variable which will iterate list till desired position.

temp=head;
int t=1;

9. Then we have started a while loop which will iterate till the position of node from beginning. That means list will iterate from t=1 to c as we have stored the position of node from beginning in c itself.

while(t<=c)
{
temp=temp->next;
t++;
}

10.At last we have printed the data in the node which was xth from then end of the list.

Clockwise Rotation of a Linked List

2020-06-29T06:01:00.000-07:00

Today we are going to discuss the algorithm for clockwise rotation of a linked list, but if you are new to linked lists then please refer to this link where I have explained everything about linked list. Let me explain you what is clockwise rotation of a linked list- Suppose we have a linked list 2->5->2->6->4->3. Then user enters an integer K=3. Now the linked list should rotate clockwise K times clockwise and we will get the linked list as 6->4->3->2->5->2.

Procedure

1. First we will make a linked list.

2. Now we will traverse the linked list. We will traverse the list till K times.

3. In each traversal we will remove the last node from linked list and insert it in the beginning of the list.

Code

#include<iostream>
using namespace std;
struct node
{
    int data;
    struct node* next;
};
struct node* head=NULL;

class linked
{
public:
    void insert(int x)
    {
        struct node* temp=new node();
        temp->data=x;
        temp->next=NULL;
        if(head==NULL)
        {
            head=temp;
        }
        else
        {
            struct node* temp1=head;
            while(temp1->next!=NULL)
            {
                temp1=temp1->next;
            }
            temp1->next =temp;
        }
    }


    void rotate(int k)
    {

        int c=0;
        while(c<k)
        {
            struct node* temp=head;
            struct node* x=NULL;
            while(temp->next->next!=NULL)
            {
                   temp=temp->next;
            }
            x=temp->next;
            temp->next=NULL;
            x->next=head;
            head=x;
            c++;
            disp();
        }


    }

    void disp()
    {
        struct node* temp=head;
        while(temp!=NULL)
        {
            cout<<temp->data<<" ";
            temp=temp->next;
        }
        cout<<endl;
    }
};

int main()
{
    linked l;
    l.insert(2);
    l.insert(5);
    l.insert(2);
    l.insert(6);
    l.insert(4);
    l.insert(3);
    l.disp();
    int n;
    cout<<"enter number of times you want to rotate the list: ";
    cin>>n;
    l.rotate(n);
    return 0;
}

Explanation of code(line by line)

1. First we will write a simple code of linked list which will have 2 functions:

- insert() - which will insert elements in the linked list.
- disp() - which will display the linked list.

2. Insert some values in the linked list.
3. Now we have created a function named rotate() to clockwise rotation of a linked list.

4. In the rotate() first we have created a variable 'c' which is initialized to 0. It will be variable which will keep track of the number of times we have to traverse the list.

5. Then we have created 'temp' which is a pointer to node variable initialized to head.

6. Then we have created 'x' which is another pointer to node variable which can store addresses of nodes only just like the head node.

7. Next we have started another while loop which will traverse from start till the second last node of the list.

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

8. Next we have stored the address of the last node of linked list in x with the help of temp->next (temp was the second last node from above while loop so its next will store the address of last node).

x=temp->next;

9. Then we have assigned temp->next = NULL because now temp->next will be the last node and last node points to NULL.

10. Then in x->next we have assigned value of head. x->next means the last node of linked list which was removed, will now point to the first node.

x->next=head;

11. Then in head we have stored address of x because now first node will be the last node which was removed and the address of last node was in x.

head=x;

12. Then c is incremented because first rotation is complete and next we will perform second rotation.

13. Then we have called disp() so that user can see the rotated linked list in each iteration.

Reverse a Linked List

2020-06-25T07:44:00.003-07:00

Today we will discuss how to reverse a linked list. Proceed if you have basic knowledge of linked list otherwise you can read this post on where I have explained you about linked list. Let me explain you what a reversed linked list is. Suppose we have a linked list 1->2->3->4->5->NULL then the reverse of this list will be 5->4->3->2->1->NULL. So, let's discuss how we can reverse a linked list.

Procedure

1. First we will make a linked list.

2. Now we will traverse the linked list.

3. While traversing when we will reach the first node we will make it point NULL.

4. Then at each node we will make that node point to the previous node.

5. When we will reach the last node then we will update head and initialize it with the address of last node.

Code

#include<iostream>
using namespace std;
struct node
{
    int data;
    struct node* next;
};
struct node* head=NULL;

class linked
{
public:
    void insert(int x)
    {
        struct node* temp=new node();
        temp->data=x;
        temp->next=NULL;
        if(head==NULL)
        {
            head=temp;
        }
        else
        {
            struct node* temp1=head;
            while(temp1->next!=NULL)
            {
                temp1=temp1->next;
            }
            temp1->next =temp;
        }
    }

    void reverse()
    {
        struct node* current=head;
        struct node* prev=head;
        struct node* forward=head;
        forward=current->next;
        current->next=NULL;
        while(current!=NULL && forward!=NULL)
        {
            prev=current;
            current=forward;
            forward=forward->next;
            current->next=prev;
        }
        head=current;
    }


    void disp()
    {
        struct node* temp=head;
        while(temp!=NULL)
        {
            cout<<temp->data<<" ";
            temp=temp->next;
        }
        cout<<endl;
    }
};

int main()
{
    linked l;
    l.insert(1);
    l.insert(2);
    l.insert(3);
    l.insert(4);
    l.insert(5);
    l.insert(6);

    l.insert(9);
    l.disp();
    l.reverse();
    l.disp();
    return 0;
}

Explanation of Code( line by line)

1. First we will write a simple code of linked list which will have 2 functions:

- insert() - which will insert elements in the linked list.
- disp() - which will display the linked list.

2. Insert some values in the linked list.
3. Now we have created a function named reverse() to reverse the linked list.
4. In the reverse() function we have made 3 pointer to node variables:

prev : Which will point to the node previous to current node.
current : Which will point to the current node.
forward : Which will point to the node ahead of current node.

5. Initially prev, current and forward are initialized with head.

6. Then forward is initialized with the next node after current.

forward=current->next;

7. Then current->next is initialized to NULL because this current is the first node and after reversing the list it will become last node so it shall point to NULL.

8. Then we have started a loop to traverse the list till current!=NULL and forward!=NULL.

9.In the loop we have assigned prev with the address of current and current with the address of forward and forward with forward->next so that all 3 pointer to node can increment.

prev=current;
current=forward;

10. Then we have assigned the current->next with the address the prev because in order to reverse the linked list each node shall point to its previous node.

current->next=prev;

11. After while loop is over we have assigned head the address of current node because when the loop will be over current will be at last node and the last node will become the first node after reversing and first node is always pointed by head node.

Search an element in Linked List

2020-06-21T05:57:00.003-07:00

Today we are going to discuss the algorithm to search an element in linked list data structure. But if you do not know what a linked list is then press on the link. Searching is a very basic problem. So let's see how to do search an element in linked list.

Procedure

1. First we will make a linked list.

2. Now we will traverse the linked list.

3. For each node we will compare its data with the value to be searched.

Code

#include<iostream>
using namespace std;
struct node
{
    int data;
    struct node* next;
};
struct node* head=NULL;

class linked
{
public:
    void insert(int x)
    {
        struct node* temp=new node();
        temp->data=x;
        temp->next=NULL;
        if(head==NULL)
        {
            head=temp;
        }
        else
        {
            struct node* temp1=head;
            while(temp1->next!=NULL)
            {
                temp1=temp1->next;
            }
            temp1->next =temp;
        }
    }

    void search(int x)
    {
         int flag=0,c=0;
         struct node* temp=head;
         while(temp!=NULL)
         {
             if(temp->data==x)
             {
                flag=1;
                break;
             }
             temp=temp->next;
             c++;
         }
         if(flag==1)
         {
             cout<<"value found at "<<c+1<<endl;
         }
         else
         {
             cout<<"value not found ";
         }

    }

    void disp()
    {
        struct node* temp=head;
        while(temp!=NULL)
        {
            cout<<temp->data<<" ";
            temp=temp->next;
        }
        cout<<endl;
    }
};

int main()
{
    linked l;
    l.insert(2);
    l.insert(5);
    l.insert(2);
    l.insert(6);
    l.insert(4);
    l.insert(5);
    l.insert(1);
    l.insert(3);
    l.insert(2);
    l.insert(6);
    l.insert(5);
    l.insert(2);
    l.insert(9);
    l.insert(7);
    l.insert(6);
    l.insert(2);
    l.insert(3);
    l.insert(3);
    l.insert(14);
    l.insert(2);
    l.disp();
    int n;
    cout<<"enter value to be searched: ";
    cin>>n;
    l.search(n);
    return 0;
}

Explanation of code(line by line)

1. First we will write a simple code of linked list which will have 2 functions:

- insert() - which will insert elements in the linked list.
- disp() - which will display the linked list.

2. Insert some values in the linked list.
3. We have made a function named search() in which we will write the algorithm for searching a value. Search() also takes an argument which is the value to be searched in the linked list.
4. We have made 3 variables.
- flag - which will indicate we have found the value to be searched or not. Initial value is 0.
- c - which will count the position of node. Initial value is 0
- temp - which is pointer to node. Initially pointing to head.
5. Next we have started the while loop which will iterate over the linked list.
6. Inside the while loop we have placed an if condition which checks if the data in current node is equal to the value to be searched or not.
7. If the data is equal to value to be searched then we make as flag=1 and break out of the loop.
8. Otherwise we will increment to next node and increment c as well.
9. After the while loop is over then we will check if flag is 1 or 0.
- If flag is 1 then we have found the value. So we display a message along with c+1 which gives the position of that value in the linked list.
- If flag is 0 then that means we have not found the value in the linked list.

Output

Remove Duplicates in Linked List

2020-06-17T06:18:00.002-07:00

Today we will discuss how to remove duplicates in linked list but before we start the discussion make sure you know about linked list. Removing duplicates from a linked list is a very famous programming problem asked in many programming interviews. So, let's start, shall we?

Procedure

1. First we will make a linked list.

2. Now we will start traversing the list in such a way that the data in each node is compared with the data of every other node.

3. While traversing the list if we encounter a duplicate then we will assign that duplicate with some special value so that we can remember that it is a duplicate.

4. Then we will delete all the nodes with the special value.

Code

#include<iostream>
using namespace std;
struct node
{
    int data;
    struct node* next;
};
struct node* head=NULL;

class linked
{
public:
    void insert(int x)
    {
        struct node* temp=new node();
        temp->data=x;
        temp->next=NULL;
        if(head==NULL)
        {
            head=temp;
        }
        else
        {
            struct node* temp1=head;
            while(temp1->next!=NULL)
            {
                temp1=temp1->next;
            }
            temp1->next =temp;
        }
    }

    void duplicate()
    {
        struct node* temp=head;
        int count=0;
        while(temp!=NULL)
        {
            count++;
            temp=temp->next;
        }
        int p=0;
        temp=head;
        while(temp->next!=NULL && p<count)
        {
            struct node* temp1=temp->next;
            while(temp1!=NULL)
            {
                if(temp->data!=-1)
                {
                    if(temp->data==temp1->data)
                    {
                         temp1->data=-1;
                    }

                }
                temp1=temp1->next;
            }
            temp=temp->next;
            p++;
        }

        temp=head;
        struct node* temp1=head;
        while(temp->next!=NULL)
        {
            if(temp->next->data==-1)
            {
                temp1=temp;
                while(temp1->next!=NULL)
                {
                    if(temp1->next->data!=-1)
                        break;
                    temp1=temp1->next;
                }
                temp->next=temp1->next;
                if(temp->next==NULL)
                    break;
            }
            temp=temp->next;
        }

    }

    void disp()
    {
        struct node* temp=head;
        while(temp!=NULL)
        {
            cout<<temp->data<<" ";
            temp=temp->next;
        }
        cout<<endl;
    }
};

int main()
{
    linked l;
    l.insert(2);
    l.insert(5);
    l.insert(2);
    l.insert(6);
    l.insert(4);
    l.insert(5);
    l.insert(1);
    l.insert(3);
    l.insert(2);
    l.insert(6);
    l.insert(5);
    l.insert(2);
    l.insert(9);
    l.insert(7);
    l.insert(6);
    l.insert(2);
    l.insert(3);
    l.insert(3);
    l.insert(14);
    l.insert(2);
    l.disp();
    l.duplicate();
    l.disp();
    return 0;
}

Explanation of code(line by line)

1. First we will write a simple code of linked list which will have 2 functions:

- insert() - which will insert elements in the linked list.
- disp() - which will display the linked list.

2. Insert some values in the linked list.
3. Now we will make a function named duplicate() which will delete duplicates from a linked list.
4. We will make a pointer to node named temp which will point to head.
5. Then we will count the number of nodes.
6. Now we will start traversing the list such that every node is compared with every other node.
7. We will use temp to traverse from beginning till second last node and temp1(another pointer to node) to traverse from second node till last node. temp will traverse in outer loop and temp1 will traverse in inner loop.

8. In this way every temp node will be compared with every temp1 node .
9. To traverse temp from beginning till second last node we will use a variable named 'p' which will traverse the list till second last node.
10. Then we have declared temp1 and initialized it with the second node and after that we have started traversing temp1 till end.
11. Now if we encounter a duplicate then we will assign that node with value -1(special value). Then there is an if statement which will check if the data of a node is not -1 because there will be chances that a node with -1 value is encountered. So, this if statement will take care of that.

12. If the data of node is not -1 then we come in the inner if statement which checks if data of temp = data of temp1. If they are equal then we assign temp1 with -1 value.
13. Then we have incremented temp1, temp and p.

14. Then we have initialized temp with head. In the next line we have made a pointer to node temp1 initialized to head.

15. Then we have started iterating over the linked list using temp.

16. The first if condition checks if the data of next node is -1 or not.

17. If the data of next node is -1 then that means it it a duplicate and we have to delete it.

18. To delete we have used temp1 and iterated it over the linked list from the node where temp is currently present.

19. We iterate temp1 till the data of next node comes out to be -1, because there may be a situation in which multiple -1's are present consecutively. In that case we have to delete all those nodes.

while(temp1->next!=NULL)
{
if(temp1->next->data!=-1)
break;
temp1=temp1->next;
}

20. Inside the loop for temp1 we have another if condition which checks if data of next node not -1 then we have to break out of the loop otherwise we will increment temp1.

21. After coming out of the loop of temp1 we have assigned temp->next = temp1->next which means temp's next will have the address of the next node which has data not equal to -1.

22. The next if statement is for the situation if the last node contains a duplicate then we break out of the loop.

if(temp->next==NULL)
break;

(try the code without including the above 2 statement and observe the output).

23. Then temp is incremented.

Swap alternate elements of Linked List pairwise

2020-06-13T06:35:00.001-07:00

Today, we will discuss how to swap alternate elements of a linked list pairwise. But before starting make sure you have basic knowledge of linked lists. So, let's start, shall we?

Procedure

1. First we will make a linked list.

2. Now we will start traversing the linked list.

3. We will use a pointer to node which will consider 2 nodes at a time and then perform a swap operation on them.

4. Then we will increment pointer to node 2 times so that next pair can be swapped.

Don't worry if you can't understand the procedure thoroughly. Keep reading till end and you will be able to solve this problem on your own.

Algorithm

First we will write a simple code of linked list which will have 2 functions:

1. insert() - which will insert elements in the linked list.

2. disp() - which will display the linked list.

Insert some values in the linked list.

Then make a function swap() which will swap alternate elements of linked list pairwise.

In the swap() function first we will make a pointer to node named temp which will initially points to the head node.

Then we will make a variable 'p' which we will use in swapping.

Now we will iterate the linked list such that the current node and the pointer to next node is not NULL which means 2 nodes exists and we will swap them. Otherwise if there exists only 1 node in the end then we will leave it as it is.

Next we will perform a swap operation between current and next node.

p=temp->data;
temp->data=temp->next->data;
temp->next->data=p;

1. In the above swapping code we have stored the data of current node in a p.

2. Then in the data of current node we have placed the data of next node. 'temp->next->data' will point to the data portion of next node.

3. Then in the data of next node we have placed the value of p.

In this way we have swapped the values of 2 alternate nodes pairwise.

At last we will double increment temp so that it will point to next pair of nodes (temp=temp->next->next).

Implementation in C++

#include<iostream>
using namespace std;
struct node
{
    int data;
    struct node* next;
};
struct node* head=NULL;
class linked
{
public:
    void insert(int x)          //insert node in a linked list
    {
        struct node* temp=new node();
        temp->data=x;
        temp->next=NULL;
        if(head==NULL)
        {
            head=temp;
        }
        else
        {
            struct node* temp1=head;
            while(temp1->next!=NULL)
            {
                temp1=temp1->next;
            }
            temp1->next=temp;
        }
    }

    void swap()   //swap alternate elements pairwise
    {
        struct node* temp=head;
        int p;
        while(temp!=NULL && temp->next!=NULL)
        {
             p=temp->data;
             temp->data=temp->next->data;
             temp->next->data=p;
             temp=temp->next->next;
        }
    }

    void disp()    //display the linked list
    {
        struct node* temp=head;
        while(temp!=NULL)
        {
            cout<<temp->data<<" ";
            temp=temp->next;
        }
        cout<<endl;
    }
};
int main()
{
    linked l;
    l.insert(2);
    l.insert(4);
    l.insert(-3);
    l.insert(-6);
    l.insert(8);
    l.insert(9);
    l.disp();
    l.swap();
    l.disp();
    return 0;
}

OUTPUT:

Delete middle element of a linked list

2020-06-10T06:58:00.000-07:00

Today we will discuss how to delete middle element of a linked list. But before moving to the solution you should be familiar with the concept of linked list.

Procedure

First we will make a linked list.
Then we will count the number of nodes in a linked list.
Now we will have 2 cases -
1.) when the number of nodes are even then we will have 2 middle elements (n/2 and n/2+1).
2.) when the number of nodes are odd then we will have 1 middle element ((n+1)/2).
Then we will write the underlying code to delete middle element by analyzing if the number of nodes are even or odd.

Algorithm

We will first write a simple code which will have 2 functions:

1. insert() - which will insert elements to linked list.
2. show() - to display the linked list.

Now we will make a function deletemiddle() which will delete the middle element.
In the deletemiddle() we will make 1 node temp1 which will initially point to head of the linked list.
Then we will count the number of nodes in the linked list by traversing the list with temp1 and storing the count values in a count variable.
Now again we will initialize temp1 to head.
Now we will check count%2 == 0 (even) or count%2!=0 (odd).

If count%2==0 or number of nodes are even then:
1. We will find mid by count/2.
2. We will make a variable p of int type which will tell us if we have reached the desired node or not.
3. Now we will traverse the list. We will increment p with each iteration and also check if p+1 == mid or not.
4. If p+1 == mid that means the next node is then first middle node and the next node is the second middle node.
5. So we will use (temp1->next=temp1->next->next->next) which means to put the address of the node after the second middle element in the current node.

If count%2!=0 or number of nodes are odd then:
1. We will find mid by count/2.
2. We will make a variable p of int type which will tell us if we have reached the desired node or not.
3. Now we will traverse the list. We will increment p with each iteration and also check if p+1 == mid or not.
4. If p+1 == mid that means the next node is then middle node .
5. 5. So we will use (temp1->next=temp1->next->next) which means to put the address of the node after the middle element in the current node.

Implementation in C++

#include<iostream>
using namespace std;
struct node
{
    int data;
    struct node* next;
};
struct node* head=NULL ;

void insert(int x)   //function it insert elements
{

    struct node* temp=new node();
    temp->data=x;
    temp->next=NULL;
    if(head==NULL)
    {
        head=temp;
    }
    else
    {
        struct node* temp1=head;
        while(temp1->next!=NULL)
        {
            temp1=temp1->next;
        }
        temp1->next=temp;
        temp->next=NULL;
    }
}

void deletemiddle()   //function to delete middle element
{
    struct node *temp1=head;
    int count=0;
    while(temp1!=NULL)    //count number of nodes in linked list
    {
        count++;
        temp1=temp1->next;
    }
    temp1=head;
    if(count%2==0)      //if number of nodes are even
    {
        int mid1=count/2;     //find mid of linked list
        int p=0;              //it will tell if we have reached mid or not
        while(temp1!=NULL)
        {
            p++;
            if(p+1==mid1)     // it means next node is the mid of linked list
            {
                temp1->next=temp1->next->next->next;
            }
            temp1=temp1->next;
        }
    }
    else if(count%2!=0)    //if number of nodes are odd
    {
        int mid=(count+1)/2;    //find mid of linked list
        int p=0;                //it will tell if we have reached mid or not
        while(temp1!=NULL)
        {
            p++;
            if(p+1==mid)        // it means next node is the mid of linked list
            {
                temp1->next=temp1->next->next;
            }
            temp1=temp1->next;
        }
    }
}

void show()          //function to display linked list
{
    struct node* temp=head;
    while(temp!=NULL)
    {
        cout<<temp->data<<"  ";
        temp=temp->next;
    }
    cout<<endl;
}

int main()
{
    insert(2);
    insert(4);
    insert(-3);
    insert(7);
    insert(9);
    insert(8);
    insert(-13);
    cout<<"original linked list: ";
    show();
    cout<<endl;
    cout<<"after deleting middle element: ";
    deletemiddle();
    show();
    return 0;
}

If you have any doubts then please ask in the comment section below.

C LOOK disk scheduling algorithm - operating system tutorial

2020-06-04T06:40:00.002-07:00

If you are new to disk scheduling then please read about basics of disk scheduling first and then read this post on C LOOK disk scheduling algorithm.

C LOOK disk scheduling algorithm is the last disk scheduling algorithm. It is a combination of C-SCAN disk scheduling algorithm and LOOK disk scheduling algorithm. So, let's start the discussion on C-LOOK disk scheduling algorithm along with its advantages and let's find out if there are some disadvantages of it or not.

C-LOOK disk scheduling algorithm

C-LOOK disk scheduling algorithm starts fulfilling the requests in one direction till it reaches the last track in that direction and then it reverts back to the other end without fulfilling any request and then again revert back and fulfill the requests and so on. It is a combination of both C-SCAN disk scheduling algorithm and LOOK disk scheduling algorithm.

Let's understand the concept with the help of an example:

98, 183, 41, 122, 14, 124, 65, 67

Fulfill the requests according to C-LOOK disk scheduling algorithm. The read/write head is at 53 initially.

soln

1. Initially the read/write head is at 53.

2. Then the read/write head will move in one direction either left or right (in my case it moves right).

3. The first request it fulfills will be 65.

4. Then it fulfills request 67.

5. Then it fulfills request 98.

6. Then it fulfills request 122.

7. Then it fulfills request 124.

8. Then it fulfills request 183.

9. Now it will not go to 199 just like LOOK algorithm and it will revert back from 183 and move till end without fulfilling any request just like C-SCAN algorithm.

10. Now it will fulfill the request 14.

11. Then it fulfills the request 41.

Advantages

1. C-LOOK disk scheduling algorithm gives a more uniform and better waiting time as compared to LOOK algorithm.

2. It is more efficient as compared to C-SCAN.

Disadvantages

1. Extra code or effort to build this algorithm.

2. It should not be used in case there is very high load.

GeekTech

What Is Cryptocurrency? Here Is Everything You Need To Know About Cryptocurrency

Program to Reverse a Queue - Code Explained

Procedure

Code

(adsbygoogle = window.adsbygoogle || []).push({});

Explanation of code

Rest API - Explained in an Easy, Quick and Simple Way

Rest API

What is Docker ? Explained in an Easy, Quick and Simple Way

What is the problem that Docker resolves?

Docker

Some best Docker Tutorials

Delete all even nodes of a Circular Linked List

Procedure

Code

Explanation of code

Exchange First and Last nodes in Circular Linked List

Procedure

Code

Explanation of code

Delete a node at kth Position in Circular Linked List

Procedure

Code

Explanation of code

Sort a Circular Linked List

Procedure

Code

Explanation of code

Reverse a Circular Linked List

Procedure

Code

Explanation of Code

What is Devops ? Explained in an Easy, Quick and Simple Way

Devops - Definition

How to Become A Full Stack Web Developer

What is Full Stack Development?

How to Become A Full Stack Web Developer?

Best resources to become Full Stack Developer

Reverse a Doubly Linked List

Procedure

Code

Explanation of Code

Find Pair with given sum in Doubly Linked List

Procedure

Code

Explanation of Code

How to find Middle Element of Doubly Linked List?

Procedure

Code

Explanation of Code (line by line)

Middle element of a Linked List

Procedure

Code

Explanation of Code

Sorting of Linked List in Increasing Order

Procedure

Code

Explanation of Code

Swap a node with its previous node in a Linked List

Procedure

Code

Explanation of code(line by line)

nth node from end of Linked List

Procedure

Code

Explanation of code(line by line)

Clockwise Rotation of a Linked List

Procedure

Code

Explanation of code(line by line)

Reverse a Linked List

Procedure

Code

Explanation of Code( line by line)

Search an element in Linked List

Procedure

Code

Explanation of code(line by line)

Output