Reverse LinkedList and Leetcode 206

Author: kalpak92

LeetCode/206. Reverse a LinkedList/Solution.cpp

@@ -0,0 +1,39 @@
+/**
+** Reverse a singly linked list.
+**
+** Example:
+**
+** Input: 1->2->3->4->5->NULL
+** Output: 5->4->3->2->1->NULL
+**/
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* reverseList(ListNode* head) {
+        if (head == NULL)
+            return head;
+        
+        ListNode* prev = NULL;
+        ListNode* current = head;
+        ListNode* next = NULL;
+        
+        while(current != NULL)
+        {
+            next = current->next;
+            current->next = prev;
+            prev = current;
+            current = next;
+        }
+        
+        head = prev;
+        return head;
+    }
+};

LeetCode/206. Reverse a LinkedList/Solution.java

@@ -0,0 +1,40 @@
+/**
+** Reverse a singly linked list.
+**
+** Example:
+**
+** Input: 1->2->3->4->5->NULL
+** Output: 5->4->3->2->1->NULL
+**/
+
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode reverseList(ListNode head) {
+        if (head == null)
+        {
+            return head;
+        }
+        
+        ListNode prev = null;
+        ListNode current = head;
+        ListNode next = null;
+        
+        while (current != null)
+        {
+            next = current.next;
+            current.next = prev;
+            prev = current;
+            current = next;
+        }
+        
+        head = prev;
+        return head;
+    }
+}

Linked List/SortedMergeOfTwoLinkedLists.c renamed to Linked List/4. MergeTwoSortedList/MergeTwoSortedList.c

@@ -0,0 +1,129 @@
+#include <iostream>
+using namespace std;
+
+class Node 
+{
+    public:
+        int data;
+        Node* nextElement;
+
+        Node()
+        {
+            nextElement = nullptr;
+        }
+};
+
+class LinkedList
+{
+    private:
+        Node* head;
+    
+    public:
+        LinkedList()
+        {
+            head = nullptr;
+        }
+
+        bool isEmpty()
+        {
+            if (head == nullptr)
+                return true;
+            else
+            {
+                return false;
+            }
+        }
+
+        // Print the LinkedList
+        bool printList()
+        {
+            if (isEmpty())
+            {
+                cout << "List is Empty" << endl;
+                return false;
+            }
+
+            Node* temp = head;
+            cout << "List: ";
+
+            while (temp != nullptr)
+            {
+                cout << temp->data << "->" ;
+                temp = temp->nextElement;
+            }
+            cout << "null" << endl;
+            return true;
+        }
+
+        // insert a new node as the first element of the list
+        void insertAtHead(int value)
+        {
+            Node* newNode = new Node();
+            newNode->data = value;
+            newNode->nextElement = head;
+            
+            head = newNode;
+            cout << value << " Inserted." << endl;
+        }
+
+        void insertAtTail(int value)
+        {
+            Node* newNode = new Node();
+            newNode->data = value;
+
+            if (isEmpty())
+            {
+                head = newNode;
+                cout << "Inserted. " << endl;
+                return;
+            }
+
+            Node* temp = head;
+            while(temp->nextElement != nullptr)
+            {
+                temp = temp->nextElement;
+            }
+            temp->nextElement = newNode;
+            cout << "Inserted." << endl;
+        }
+
+        void revereLinkedList()
+        {
+            if (head == NULL)
+            {
+                cout << "Empty Linked List. Cannot reverse." << endl;
+            }
+
+            Node* prev = NULL;
+            Node* current = head;
+            Node* next = NULL;
+
+            while(current != NULL)
+            {
+                next = current->nextElement;
+                current->nextElement = prev;
+                prev = current;
+                current = next;
+            }
+            head = prev;
+        }
+};
+
+int main()
+{
+    LinkedList list; // LinkedList created
+
+    for (int i = 0; i < 10; i++)
+    {
+        list.insertAtHead(i+1);
+        //list.printList();
+    }
+
+    list.printList();
+
+    cout << "Reverse LinkedList: " << endl;
+    list.revereLinkedList();
+    list.printList();
+    
+    return 0;
+}

Linked List/ReverseALinkedList.c renamed to Linked List/5. Reverse a LinkedList/ReverseALinkedList.c

@@ -0,0 +1,98 @@
+class Node { 
+  
+    int value; 
+    Node next; 
+
+    Node(int d) 
+    { 
+        value = d; 
+        next = null; 
+    } 
+}
+public class ReverseALinkedList
+{
+    private Node head;
+
+    public boolean isEmpty()
+    {
+        if (head == null)
+            return true;
+        else
+            return false;
+    }
+
+    public void printList()
+    {
+        if (isEmpty())
+            System.out.println("LinkedList is Empty");
+        
+        Node temp = head;
+
+        while (temp != null)
+        {
+            System.out.print(temp.value + "->");
+            temp = temp.next;
+        }
+        System.out.println("null");
+    }
+
+    public void insertAtTail(int value)
+    {
+        Node newNode = new Node(value);
+
+        if (isEmpty())
+        {
+            newNode.next = head;
+            head = newNode;
+            System.out.println(value + " has been inserted.");
+            return;
+        }
+
+        Node temp = head;
+        while (temp.next != null)
+        {
+            temp = temp.next;
+        }
+        temp.next = newNode;
+        System.out.println(value + " has been inserted.");
+    }
+
+    public void reverseLinkedList()
+    {
+        if (head == null)
+        {
+            System.out.println("Empty List. Cannot reverse!!");
+            return;
+        }
+        
+        Node prev = null;
+        Node current = head;
+        Node next = null;
+
+        while(current != null)
+        {
+            next = current.next;
+            current.next = prev;
+            prev = current;
+            current = next;
+        }
+        head = prev;
+    }
+
+    public static void main(String[] args) {
+        ReverseALinkedList list = new ReverseALinkedList();
+
+        for(int i = 0; i < 10; i++)
+        {
+            list.insertAtTail(i);
+        }
+
+        list.printList();
+
+        list.reverseLinkedList();
+
+        System.out.println("Reversed List: ");
+        list.printList();
+
+    }
+}