diff --git a/PriorityQueueTest.java b/PriorityQueueTest.java
new file mode 100644
index 0000000..830aa05
--- /dev/null
+++ b/PriorityQueueTest.java
@@ -0,0 +1,158 @@
+import java.util.Scanner;
+ 
+/** class Task **/
+class Task
+{
+    String job;
+    int priority;
+ 
+    /** Constructor **/
+    public Task(String job, int priority)
+    {
+        this.job = job;
+        this.priority = priority; 
+    }
+    /** toString() **/
+    public String toString() 
+    {
+        return "Job Name : "+ job +"\nPriority : "+ priority;
+    }
+}
+ 
+/** Class PriorityQueue **/
+class PriorityQueue
+{
+    private Task[] heap; 
+    private int heapSize, capacity;
+ 
+    /** Constructor **/
+    public PriorityQueue(int capacity)
+    {    
+        this.capacity = capacity + 1;
+        heap = new Task[this.capacity];
+        heapSize = 0;
+    }
+    /** function to clear **/
+    public void clear()
+    {
+        heap = new Task[capacity];
+        heapSize = 0;
+    }
+    /** function to check if empty **/
+    public boolean isEmpty()
+    {
+        return heapSize == 0;
+    }
+    /** function to check if full **/
+    public boolean isFull()
+    {
+        return heapSize == capacity - 1;
+    }
+    /** function to get Size **/
+    public int size()
+    {
+        return heapSize;
+    }
+    /** function to insert task **/
+    public void insert(String job, int priority)
+    {
+        Task newJob = new Task(job, priority);
+ 
+        heap[++heapSize] = newJob;
+        int pos = heapSize;
+        while (pos != 1 && newJob.priority > heap[pos/2].priority)
+        {
+            heap[pos] = heap[pos/2];
+            pos /=2;
+        }
+        heap[pos] = newJob;    
+    }
+    /** function to remove task **/
+    public Task remove()
+    {
+        int parent, child;
+        Task item, temp;
+        if (isEmpty() )
+        {
+            System.out.println("Heap is empty");
+            return null;
+        }
+ 
+        item = heap[1];
+        temp = heap[heapSize--];
+ 
+        parent = 1;
+        child = 2;
+        while (child <= heapSize)
+        {
+            if (child < heapSize && heap[child].priority < heap[child + 1].priority)
+                child++;
+            if (temp.priority >= heap[child].priority)
+                break;
+ 
+            heap[parent] = heap[child];
+            parent = child;
+            child *= 2;
+        }
+        heap[parent] = temp;
+ 
+        return item;
+    }
+}
+ 
+/** Class PriorityQueueTest **/
+public class PriorityQueueTest
+{
+    public static void main(String[] args)
+    {
+        Scanner scan = new Scanner(System.in);
+        System.out.println("Priority Queue Test\n");   
+ 
+        System.out.println("Enter size of priority queue ");
+        PriorityQueue pq = new PriorityQueue(scan.nextInt() );
+ 
+        char ch;
+        /*  Perform Priority Queue operations */
+        do    
+        {
+            System.out.println("\nPriority Queue Operations\n");
+            System.out.println("1. insert");
+            System.out.println("2. remove");
+            System.out.println("3. check empty");
+            System.out.println("4. check full");
+            System.out.println("5. clear");
+            System.out.println("6. size");
+ 
+            int choice = scan.nextInt();            
+            switch (choice) 
+            {
+            case 1 : 
+                System.out.println("Enter job name and priority");
+                pq.insert(scan.next(), scan.nextInt() );                     
+                break;                          
+            case 2 : 
+                System.out.println("\nJob removed \n\n"+ pq.remove()); 
+                break;        
+            case 3 : 
+                System.out.println("\nEmpty Status : "+ pq.isEmpty() );
+                break; 
+            case 4 : 
+                System.out.println("\nFull Status : "+ pq.isFull() );
+                break; 
+            case 5 : 
+                System.out.println("\nPriority Queue Cleared");
+                pq.clear();
+                break;    
+            case 6 : 
+                System.out.println("\nSize = "+ pq.size() );
+                break;         
+            default : 
+                System.out.println("Wrong Entry \n ");
+                break;   
+            }    
+ 
+            System.out.println("\nDo you want to continue (Type y or n) \n");
+            ch = scan.next().charAt(0);                        
+        } while (ch == 'Y'|| ch == 'y');            
+    }
+}
\ No newline at end of file
diff --git a/Quick_sort.java b/Quick_sort.java
index e9d2f60..804ed43 100644
--- a/Quick_sort.java
+++ b/Quick_sort.java
@@ -1,63 +1,42 @@
-
-class QuickSort
-{
-	
-	int partition(int arr[], int low, int high)
-	{
-		int pivot = arr[high];
-		int i = (low-1); 
-		for (int j=low; j<high; j++)
-		{
-			
-			if (arr[j] <= pivot)
-			{
-				i++;
-
-			
-				int temp = arr[i];
-				arr[i] = arr[j];
-				arr[j] = temp;
-			}
-		}
-
-		
-		int temp = arr[i+1];
-		arr[i+1] = arr[high];
-		arr[high] = temp;
-
-		return i+1;
-	}
-
-	void sort(int arr[], int low, int high)
-	{
-		if (low < high)
-		{
-			int pi = partition(arr, low, high);
-			sort(arr, low, pi-1);
-			sort(arr, pi+1, high);
-		}
-	}
-
-
-	static void printArray(int arr[])
-	{
-		int n = arr.length;
-		for (int i=0; i<n; ++i)
-			System.out.print(arr[i]+" ");
-		System.out.println();
-	}
-
-
-	public static void main(String args[])
-	{
-		int arr[] = {10, 7, 8, 9, 1, 5};
-		int n = arr.length;
-
-		QuickSort ob = new QuickSort();
-		ob.sort(arr, 0, n-1);
-
-		System.out.println("sorted array");
-		printArray(arr);
-	}
+import java.util.*;
+class QuickSort { 
+    int partition(int intArray[], int low, int high) { 
+        int pi = intArray[high];  
+        int i = (low-1);
+        for (int j=low; j<high; j++) { 
+            if (intArray[j] <= pi) { 
+                i++; 
+                int temp = intArray[i]; 
+                intArray[i] = intArray[j]; 
+                intArray[j] = temp; 
+            } 
+        } 
+   
+        int temp = intArray[i+1]; 
+        intArray[i+1] = intArray[high]; 
+        intArray[high] = temp; 
+   
+        return i+1; 
+    } 
+   
+
+    void quick_sort(int intArray[], int low, int high) { 
+        if (low < high) { 
+            int pi = partition(intArray, low, high); 
+   
+            quick_sort(intArray, low, pi-1); 
+            quick_sort(intArray, pi+1, high); 
+        } 
+    } 
+}
+ 
+class Main{
+    public static void main(String args[]) {
+        int intArray[] = {4,-1,6,8,0,5,-3}; 
+        int n = intArray.length; 
+        System.out.println("Original Array: " + Arrays.toString(intArray));
+        QuickSort obj = new QuickSort(); 
+        obj.quick_sort(intArray, 0, n-1); 
+        System.out.println("\nSorted Array: " + Arrays.toString(intArray)); 
+    } 
 }
-
diff --git a/Stack.java b/Stack.java
deleted file mode 100644
index 8492243..0000000
--- a/Stack.java
+++ /dev/null
@@ -1,88 +0,0 @@
-// Stack implementation in Java
-
-class Stack {
-
-  // store elements of stack
-  private int arr[];
-  // represent top of stack
-  private int top;
-  // total capacity of the stack
-  private int capacity;
-
-  // Creating a stack
-  Stack(int size) {
-    // initialize the array
-    // initialize the stack variables
-    arr = new int[size];
-    capacity = size;
-    top = -1;
-  }
-
-  // push elements to the top of stack
-  public void push(int x) {
-    if (isFull()) {
-      System.out.println("Stack OverFlow");
-
-      // terminates the program
-      System.exit(1);
-    }
-
-    // insert element on top of stack
-    System.out.println("Inserting " + x);
-    arr[++top] = x;
-  }
-
-  // pop elements from top of stack
-  public int pop() {
-
-    // if stack is empty
-    // no element to pop
-    if (isEmpty()) {
-      System.out.println("STACK EMPTY");
-      // terminates the program
-      System.exit(1);
-    }
-
-    // pop element from top of stack
-    return arr[top--];
-  }
-
-  // return size of the stack
-  public int getSize() {
-    return top + 1;
-  }
-
-  // check if the stack is empty
-  public Boolean isEmpty() {
-    return top == -1;
-  }
-
-  // check if the stack is full
-  public Boolean isFull() {
-    return top == capacity - 1;
-  }
-
-  // display elements of stack
-  public void printStack() {
-    for (int i = 0; i <= top; i++) {
-      System.out.print(arr[i] + ", ");
-    }
-  }
-
-  public static void main(String[] args) {
-    Stack stack = new Stack(5);
-
-    stack.push(1);
-    stack.push(2);
-    stack.push(3);
-
-    System.out.print("Stack: ");
-    stack.printStack();
-
-    // remove element from stack
-    stack.pop();
-    System.out.println("\nAfter popping out");
-    stack.printStack();
-
-  }
-}