Precourse-1

.gitignore

@@ -0,0 +1 @@
+.idea

Exercise_1.java

@@ -1,46 +1,62 @@
-class Stack { 
+class Stack {
     //Please read sample.java file before starting.
-  //Kindly include Time and Space complexity at top of each file
-    static final int MAX = 1000; 
-    int top; 
-    int a[] = new int[MAX]; // Maximum size of Stack 
-
-    boolean isEmpty() 
-    { 
-        //Write your code here 
-    } 
+    //Kindly include Time and Space complexity at top of each file
+    static final int MAX = 1000;
+    int top;
+    int a[] = new int[MAX]; // Maximum size of Stack
 
-    Stack() 
-    { 
-        //Initialize your constructor 
-    } 
-
-    boolean push(int x) 
-    { 
+    boolean isEmpty()
+    {
+        //Write your code here
+        return top == -1;
+    }
+
+    Stack()
+    {
+        //Initialize your constructor
+        top = -1;
+    }
+
+    boolean push(int x)
+    {
         //Check for stack Overflow
+        if(top == MAX-1) return false;
         //Write your code here
-    } 
-
-    int pop() 
-    { 
+        a[top + 1] = x;
+        return true;
+    }
+
+    int pop()
+    {
         //If empty return 0 and print " Stack Underflow"
+        if(top == -1) {
+            System.out.println("Stack Underflow");
+            return 0;
+        }
         //Write your code here
-    } 
-
-    int peek() 
-    { 
+        int x = a[top];
+        top = top - 1;
+        return x;
+    }
+
+    int peek()
+    {
         //Write your code here
-    } 
-} 
-
-// Driver code 
-class Main { 
-    public static void main(String args[]) 
-    { 
-        Stack s = new Stack(); 
-        s.push(10); 
-        s.push(20); 
-        s.push(30); 
-        System.out.println(s.pop() + " Popped from stack"); 
-    } 
+        if(top == -1) {
+            return 0;
+        }
+        return a[top];
+    }
+}
+
+// Driver code
+class Main {
+    public static void main(String args[])
+    {
+        Stack s = new Stack();
+        s.push(10);
+        s.push(20);
+        s.push(30);
+        System.out.println(s.pop() + " Popped from stack");
+    }
 }

LinkedList.java

@@ -0,0 +1,87 @@
+import java.io.*;
+
+// Java program to implement
+// a Singly Linked List
+public class LinkedList {
+
+    Node head; // head of list
+
+    // Linked list Node.
+    // This inner class is made static
+    // so that main() can access it
+    static class Node {
+
+        int data;
+        Node next;
+
+        // Constructor
+        Node(int d)
+        {
+            //Write your code here
+            data = d;
+            next = null;
+        }
+    }
+
+    // Method to insert a new node
+    public static LinkedList insert(LinkedList list, int data)
+    {
+        // Create a new node with given data
+        Node newNode = new Node(data);
+
+        // If the Linked List is empty,
+        // then make the new node as head
+        if(list.head == null) {
+            list.head = newNode;
+        }
+
+        // Else traverse till the last node
+        // and insert the new_node there
+        else {
+            Node temp = list.head;
+            while(temp.next != null) {
+
+                temp = temp.next;
+            }
+            // Insert the new_node at last node
+            temp.next = newNode;
+        }
+
+        // Return the list by head
+        return list;
+    }
+
+    // Method to print the LinkedList.
+    public static void printList(LinkedList list)
+    {
+        Node temp = list.head;
+        // Traverse through the LinkedList
+        while(temp != null) {
+            // Print the data at current node
+            System.out.println(temp.data);
+            // Go to next node
+            temp = temp.next;
+        }
+    }
+
+    // Driver code
+    public static void main(String[] args)
+    {
+        /* Start with the empty list. */
+        LinkedList list = new LinkedList();
+
+        //
+        // ******INSERTION******
+        //
+
+        // Insert the values
+        list = insert(list, 1);
+        list = insert(list, 2);
+        list = insert(list, 3);
+        list = insert(list, 4);
+        list = insert(list, 5);
+
+        // Print the LinkedList
+        printList(list);
+    }
+}

StackAsLinkedList.java

@@ -0,0 +1,73 @@
+import java.util.*;
+
+public class StackAsLinkedList {
+
+    StackNode root;
+
+    static class StackNode {
+        int data;
+        StackNode next;
+
+        StackNode(int data)
+        {
+            //Constructor here
+            this.data = data;
+        }
+    }
+
+
+    public boolean isEmpty()
+    {
+        //Write your code here for the condition if stack is empty.
+        return root == null;
+    }
+
+    public void push(int data)
+    {
+        StackNode next = new StackNode(data);
+        //Write code to push data to the stack.
+        if(root == null) {
+            root = next;
+        } else {
+            StackNode temp = root;
+            root = next;
+            root.next = temp;
+        }
+    }
+
+    public int pop()
+    {
+        //If Stack Empty Return 0 and print "Stack Underflow"
+        //Write code to pop the topmost element of stack.
+        //Also return the popped element
+        if(root == null) {
+            System.out.print("Stack Underflow");
+            return 0;
+        } else {
+            int x = root.data;
+            root = root.next;
+            return x;
+        }
+    }
+
+    public int peek()
+    {
+        //Write code to just return the topmost element without removing it.
+        return root.data;
+    }
+
+    //Driver code
+    public static void main(String[] args)
+    {
+
+        StackAsLinkedList sll = new StackAsLinkedList();
+
+        sll.push(10);
+        sll.push(20);
+        sll.push(30);
+
+        System.out.println(sll.pop() + " popped from stack");
+
+        System.out.println("Top element is " + sll.peek());
+    }
+}