diff --git a/src/main/java/com/thealgorithms/datastructures/LinkedList/Doubly/doubly_ll.java b/src/main/java/com/thealgorithms/datastructures/LinkedList/Doubly/doubly_ll.java
new file mode 100644
index 000000000000..74dde6844d2f
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/LinkedList/Doubly/doubly_ll.java
@@ -0,0 +1,89 @@
+import java.util.*;
+
+public class DoubelLL
+{
+    static class Node{
+        int data;
+        Node next;
+        Node prev;
+        
+        Node(int data){
+            this.data=data;
+            next=prev=null;
+        }
+    }
+    static Node head;
+    static Node tail;
+    public void addFirst(int data){
+        Node newNode=new Node(data);
+        if(head==null){
+            head=tail=newNode;
+            return;
+        }
+        newNode.next=head;
+        head.prev=newNode;
+        head=newNode;
+    }
+    static void removeLast(){
+        if(head==null){
+          System.out.println("Empty...");
+          return;
+        }
+        else if(head.next==null){
+            head=tail=null;
+            return;
+        }
+        Node curr=head;
+        while(curr.next!=tail){
+            curr=curr.next;
+        }
+        curr.next.prev=null;
+        curr.next=null;
+        tail=curr;
+    }
+    static void removeFirst(){
+         if(head==null){
+          System.out.println("Empty...");
+          return;
+        }
+        else if(head.next==null){
+            head=tail=null;
+            return;
+        }
+        head=head.next;
+        head.prev=null;
+        
+        
+    }
+   
+    static void show(){
+        Node curr=head;
+        while(curr!=null){
+            System.out.print(curr.data+" ");
+            curr=curr.next;
+        }
+        System.out.println();
+    }
+    static void printInReverse(){
+        Node curr=tail;
+        while(curr!=null){
+            System.out.print(curr.data+" ");
+            curr=curr.prev;
+        }
+    }
+	public static void main(String[] args) {
+		DoubelLL dl=new DoubelLL();
+		dl.addFirst(5);
+		dl.addFirst(4);
+		dl.addFirst(3);
+		dl.addFirst(2);
+		dl.addFirst(1);
+		show();
+		removeLast();
+		show();
+		removeFirst();
+		show();
+		System.out.println("Now print in Reverse Order...");
+		printInReverse();
+	}
+}
diff --git a/src/main/java/com/thealgorithms/datastructures/LinkedList/Linked_list.java b/src/main/java/com/thealgorithms/datastructures/LinkedList/Linked_list.java
new file mode 100644
index 000000000000..3ee5c22ec054
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/LinkedList/Linked_list.java
@@ -0,0 +1,116 @@
+import java.util.*;
+public class LinkedListt{
+    static class Node{
+        int data;
+        Node next;
+        Node(int data){
+            this.data=data;
+            next=null;
+        }
+    }
+    public static Node head;
+    public static Node tail;
+    public void addFirst(int data){
+        Node newNode=new Node(data);
+        if(head==null){
+            head=tail=newNode;
+            return;
+        }
+
+        newNode.next=head;
+        head=newNode;
+    }
+    public void addlast(int data){
+        Node newNode=new Node(data);
+        if(head==null){
+            head=tail=newNode;
+            return;
+        }
+//        while(tail.next!=null){
+//            tail=tail.next;
+//        }
+        tail.next=newNode;
+        tail=newNode;
+    }
+    public  void addMiddle(int data,int index){
+        Node newNode=new Node(data);
+        int i=1;
+        Node curr=head;
+        while(i<index){
+            curr=curr.next;
+            i++;
+        }
+        newNode.next=curr.next;
+        curr.next=newNode;
+    }
+    public void removeFirst(){
+        if(head==null){
+            System.out.println("LL is empty()");
+            return;
+        }
+        else if (head.next==null){
+            head=tail=null;
+            return;
+        }
+        System.out.println("deleted data:"+head.data);
+        head=head.next;
+        return;
+    }
+    public  void removeLast(){
+        if(head==null){
+            System.out.println("LL is empty()");
+            return;
+        }
+        else if(head.next==null){
+            head=tail=null;
+            return;
+        }
+        Node curr=head;
+        while(curr.next!=tail){
+            curr=curr.next;
+        }
+        System.out.println("deleted data:"+tail.data);
+        curr.next=null;
+        tail=curr;
+    }
+    public void show(){
+        Node curr=head;
+        while(curr!=null){
+            System.out.print(curr.data+" ");
+            curr=curr.next;
+        }
+        System.out.println();
+    }
+
+    public int size(){
+        Node curr=head;
+        int count=0;
+        while(curr!=null){
+            count++;
+            curr=curr.next;
+        }
+        return count;
+    }
+
+    public static  void main(String args[]){
+       LinkedListt ll=new LinkedListt();
+       ll.addFirst(1);
+       ll.addFirst(2);
+       ll.addFirst(3);
+       ll.addlast(4);
+       ll.addlast(5);
+       ll.addlast(6);
+       ll.show();
+       int siz=ll.size();
+       System.out.println("Size of LinkedList:"+siz);
+      // int index=siz%2==0?siz/2 : siz/2 +1;
+      ll.addMiddle(55,siz/2);
+       ll.show();
+      System.out.println("Remove the first data");
+      ll.removeFirst();
+      ll.show();
+      ll.removeLast();
+      ll.show();
+
+    }
+}
diff --git a/src/main/java/com/thealgorithms/datastructures/LinkedList/Rearrange a Linked List in Zig-Zag fashion.java b/src/main/java/com/thealgorithms/datastructures/LinkedList/Rearrange a Linked List in Zig-Zag fashion.java
new file mode 100644
index 000000000000..baac17e5f15a
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/LinkedList/Rearrange a Linked List in Zig-Zag fashion.java	
@@ -0,0 +1,79 @@
+import java.util.*;
+
+public class LinekedList
+{
+     static class Node{
+         int data;
+         Node next;
+         
+         Node(int data){
+             this.data=data;
+             next=null;
+         }
+     }
+     static Node head;
+     static Node tail;
+     static void addLast(int data){
+         Node newNode=new Node(data);
+         if(head==null){
+             head=tail=newNode;
+             return;
+         }
+         tail.next=newNode;
+         tail=newNode;
+     }
+     static void show(Node head){
+         Node curr=head;
+         while(curr!=null){
+             System.out.print(curr.data+" ");
+             curr=curr.next;
+         } 
+         System.out.println();
+     }
+     static Node getMid(Node head){
+         Node slow=head;
+         Node fast=head.next;
+         
+         while(fast!=null && fast.next!=null){
+             slow=slow.next;
+             fast=fast.next.next;
+         }
+         return slow;
+     }
+     static Node reverse(Node mid){
+         
+         Node curr=mid;
+         Node prev=null;
+         while(curr!=null){
+             Node temp=curr.next;
+             curr.next=prev;
+             prev=curr;
+             curr=temp;
+         }
+         return prev;
+     }
+	public static void main(String[] args) {
+	   LinekedList ll=new LinekedList();
+	   ll.addLast(1);
+	   ll.addLast(2);
+	   ll.addLast(3);
+	   ll.addLast(4);
+	  ll.addLast(5);
+	   
+	   Node mid=getMid(head);
+	   Node head2=reverse(mid);
+	   
+	   Node head1=head;
+	   Node dummy=new Node(-1);
+	   Node temp=dummy;
+	   while(head1!=mid && head2!=null){
+	       temp.next=head1;
+	       temp=temp.next;
+	       head1=head1.next;
+	       temp.next=head2;
+	       head2=head2.next;
+	       temp=temp.next;
+	   }
+	   show(dummy.next);
+	}
+}
diff --git a/src/main/java/com/thealgorithms/datastructures/LinkedList/Search_LL.java b/src/main/java/com/thealgorithms/datastructures/LinkedList/Search_LL.java
new file mode 100644
index 000000000000..397e54f68e67
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/LinkedList/Search_LL.java
@@ -0,0 +1,49 @@
+import java.util.*;
+public class LinkedList{
+    static class Node{
+        int data;
+        Node next;
+        Node(int data){
+            this.data=data;
+            next=null;
+        }
+    }
+    static Node head;
+    static Node tail;
+    void addFirst(int data){
+        Node newNode=new Node(data);
+        if(head==null){
+            head=tail=newNode;
+            return;
+        }
+        newNode.next=head;
+        head=newNode;
+    }
+    void addLast(int data){
+         Node newNode=new Node(data);
+        if(head==null){
+            head=tail=newNode;
+            return;
+        }
+        tail.next=newNode;
+        tail=newNode;
+    }
+    int search(Node curr,int val,int i){
+        if(curr==null){
+            return -1;
+        }
+        if(curr.data==val){
+            return i+1;
+        }
+        return search(curr.next,val,i+1);
+    }
+    public static void main(String args[]){
+        LinkedList ll=new LinkedList();
+        ll.addFirst(4);
+        ll.addFirst(3);
+        ll.addLast(2);
+     
+       System.out.println(ll.search(head,3,0));
+       
+    }
+}
diff --git a/src/main/java/com/thealgorithms/datastructures/LinkedList/dry_run_Odd Even Linked List.java b/src/main/java/com/thealgorithms/datastructures/LinkedList/dry_run_Odd Even Linked List.java
new file mode 100644
index 000000000000..818d014a8115
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/LinkedList/dry_run_Odd Even Linked List.java	
@@ -0,0 +1,49 @@
+import java.util.*;
+
+public class LinkedList
+{   
+    static class Node{
+        int data;
+        Node next;
+        Node(int data){
+            this.data=data;
+            next=null;
+        }
+    }
+    static Node head;
+    static Node tail;
+    void add(int data){
+        Node newNode=new Node(data);
+        if(head==null){
+          head=tail=newNode;
+          return;
+        }
+        newNode.next=head;
+        head=newNode;
+    }
+    void show(){
+      Node curr=head;
+      while(curr!=null){
+          System.out.print(curr.data+" ");
+          curr=curr.next;
+      }
+     System.out.println();
+    }
+    void segregate(){
+       Node odd=head;
+       Node even=head.next;
+       odd.next=even.next;
+       odd=odd.next;
+       System.out.println(odd.data);
+    }
+	public static void main(String[] args) {
+		LinkedList ll=new LinkedList();
+		ll.add(5);
+		ll.add(4);
+		ll.add(3);
+		ll.add(2);
+		ll.add(1);
+		ll.show();
+		ll.segregate();
+	}
+}
diff --git a/src/main/java/com/thealgorithms/datastructures/LinkedList/palindrome.java b/src/main/java/com/thealgorithms/datastructures/LinkedList/palindrome.java
new file mode 100644
index 000000000000..816a825470ef
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/LinkedList/palindrome.java
@@ -0,0 +1,72 @@
+import java.util.*;
+
+public class LinkedList
+{  
+    
+    static class Node{
+        int data;
+        Node next;
+        Node(int data){
+            this.data=data;
+            next=null;
+        }
+    }
+    static Node head;
+    static Node tail;
+    void addFirst(int data){
+        Node newNode=new Node(data);
+        if(head==null){
+            head=tail=newNode;
+            return;
+        }
+        newNode.next=head;
+        head=newNode;
+    }
+    public Node findMid(){
+        Node slow=head;
+        Node fast=head;
+        while(fast!=null && fast.next!=null){
+            slow=slow.next;
+            fast=fast.next.next;
+        }
+        return slow;
+    }
+    Node reverseMid(Node mid){
+        Node curr=mid;
+        Node prev=null;
+        while(curr!=null){
+            Node temp=curr.next;
+            curr.next=prev;
+            prev=curr;
+            curr=temp;
+        }
+        return prev;
+    }
+    void show(Node prev){
+        Node curr=prev;
+        while(curr!=null){
+            System.out.print(curr.data+"-->");
+            curr=curr.next;
+        }
+         System.out.println();
+    }
+    
+    
+    
+	public static void main(String[] args) {
+	   LinkedList li=new LinkedList();
+	   li.addFirst(1);
+	   li.addFirst(2);
+	   li.addFirst(3);
+	   li.addFirst(4);
+	   li.addFirst(5);
+	 //  li.show();
+	   Node mid=li.findMid();
+	   Node prev=li.reverseMid(mid);//2nd half ka head prev hi hoga
+	   li.show(prev);
+	   
+	   
+	   
+	   
+	}
+}
diff --git a/src/main/java/com/thealgorithms/datastructures/LinkedList/zig_zag_ll.java b/src/main/java/com/thealgorithms/datastructures/LinkedList/zig_zag_ll.java
new file mode 100644
index 000000000000..492499074f79
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/LinkedList/zig_zag_ll.java
@@ -0,0 +1,114 @@
+import java.util.*;
+public class LinkedList
+{  
+      static class Node{
+          char item;
+          Node next;
+          Node(char item){
+              this.item=item;
+              next=null;
+          }
+      }
+     static Node head1;
+     static Node tail1;
+     static Node head2;
+     static Node tail2;
+     
+    //   static void join_ll(Node left,Node right){
+          
+    //       if(left==null  || right==null){
+    //           if(left==null){
+    //               temp.next=right;
+    //               return;
+    //           }
+    //           else{
+    //               temp.next=left;
+    //               return;
+    //           }
+    //       }
+    //       temp.next=left;
+    //       temp=temp.next;
+    //       temp.next=right;
+    //       temp=temp.next;
+    //       join_ll(left.next,right.next);
+    //   }
+    static Node join_ll(Node left,Node right){
+          Node dummy=new Node('z');
+      Node temp=dummy;
+        
+        while(left!=null && right!=null){
+            temp.next=left;
+            left=left.next;
+            temp=temp.next;
+            temp.next=right;
+            right=right.next;
+             temp=temp.next;
+        }
+        while(left!=null){
+            temp.next=left;
+            left=left.next;
+            temp=temp.next;
+        }
+        while(right!=null){
+            temp.next=right;
+            right=right.next;
+             temp=temp.next;
+        }
+        
+        return dummy.next;
+         
+    }
+      static void show(Node head_new){
+          Node curr=head_new;
+          while(curr!=null){
+              System.out.print(curr.item+"->");
+              curr=curr.next;
+          }
+          System.out.println();
+      }
+      static void addLast_left(char item){
+          Node newNode=new Node(item);
+          if(head1==null){
+              head1=tail1=newNode;
+              return;
+          }
+          tail1.next=newNode;
+          tail1=newNode;
+      }
+    static void addLast_right(char item){
+          Node newNode=new Node(item);
+          if(head2==null){
+              head2=tail2=newNode;
+              return;
+          }
+          tail2.next=newNode;
+          tail2=newNode;
+      }
+	public static void main(String[] args) {
+// 	  a->b->c->d;
+// 	  1->2->3;
+// 	  a->1->b->2->c-3->d;
+      LinkedList left=new LinkedList();
+      left.addLast_left('a');
+      left.addLast_left('b');
+      left.addLast_left('c');
+      left.addLast_left('d');
+      left.addLast_left('e');
+      left.addLast_left('f');
+      
+     LinkedList right=new LinkedList();
+     right.addLast_right('1');
+     right.addLast_right('2');
+     right.addLast_right('3');
+    // if(right==null  && right==null){
+    //     System.out.println("Botha re null");
+    // }
+    // 
+    // print_ll(dummy.next);
+    // show(head2);
+    // show(head1);
+    Node new_pointer=join_ll(head1,head2);
+    show(new_pointer);
+    
+}
+}