MyLinkedList : Implemented with Generics

MyLinkedList:

package com.lnn.ds;

import java.util.Objects;

public class MyLinkedList<T> {

      private static class MyLink<T> {

            private MyLink<T> prev;

            private MyLink<T> next;

            private T data;

            public MyLink(T data) {

                  this.data = data;

            }

            public T getData() {

                  return data;

            }

            public MyLink<T> getNext() {

                  return next;

            }

            public MyLink<T> getPrev() {

                  return prev;

            }

            public void setNext(MyLink<T> next) {

                  this.next = next;

            }

            public void setPrev(MyLink<T> prev) {

                  this.prev = prev;

            }

      }

      private MyLink<T> head;

      private MyLink<T> tail;

      public void addFirst(T data) {

            MyLink<T> prev = new MyLink<T>(data);

            prev.setNext(head);

            if (head != null) {

                  head.setPrev(prev);

            }

            head = prev;

            if (tail == null) {

                  tail = prev;

            }

      }

      public void addLast(T data) {

            MyLink<T> next = new MyLink<T>(data);

            next.setPrev(tail);

            if (tail != null) {

                  tail.setNext(next);

            }

            tail = next;

            if (head == null) {

                  head = next;

            }

      }

      public void display() {

            MyLink<T> tmp = head;

            System.out.print("[");

            while (tmp != null) {

                  System.out.print(tmp.getData());

                  tmp = tmp.getNext();

                  if (tmp != null) {

                        System.out.print(", ");

                  }

            }

            System.out.println("]");

      }

      public boolean exists(T data) {

            MyLink<T> tmp = head;

            while (tmp != null) {

                  if (Objects.equals(tmp.getData(), data)) {

                        return true;

                  }

                  tmp = tmp.getNext();

            }

            return false;

      }

      public boolean remove(T data) {

            MyLink<T> tmp = head;

            while (tmp != null) {

                  if (Objects.equals(tmp.getData(), data)) {

                        MyLink<T> prev = tmp.getPrev();

                        MyLink<T> next = tmp.getNext();

                        if (prev != null) {

                              prev.setNext(next);

                        } else {

                              head = next;

                        }

                        if (next != null) {

                              next.setPrev(prev);

                        } else {

                              tail = prev;

                        }

                        return true;

                  }

                  tmp = tmp.getNext();

            }

            return false;

      }

      public boolean removeFirst() {

            if (head != null) {

                  head = head.getNext();

                  if (head != null) {

                        head.setPrev(null);

                  } else {

                        tail = head;

                  }

                  return true;

            }

            return false;

      }

      public boolean removeLast() {

            if (tail != null) {

                  tail = tail.getPrev();

                  if (tail != null) {

                        tail.setNext(null);

                  } else {

                        head = tail;

                  }

                  return true;

            }

            return false;

      }

}

TestMyLinkedList:

package com.lnn.ds;

public class TestMyLinkedList {

      public static void main(String[] args) {

            MyLinkedList<Integer> list = new MyLinkedList<Integer>();

            for (int i = 1; i < 10; i++) {

                  list.addFirst(10 - i);

            }

            for (int i = 10; i < 20; i++) {

                  list.addLast(i);

            }

            list.display();

            list.remove(7);

            list.display();

            list.removeLast();

            list.display();

            list.removeFirst();

            list.display();

            System.out.println(list.exists(9));

      }

}

Quick Sort in Java

import java.util.Comparator;

public class QuickSort {

      public static void main(String a[]) {

            String[] strs = { "one", "two", "three", "four", "five", "six",

                        "seven", "eight", "nine", "ten" };

            quickSort(strs, 0, strs.length - 1);

            for (String str : strs) {

                  System.out.print(str);

                  System.out.print(" ");

            }

      }

      /**

       * This method will sort the int type array in ascending order

       * @param array

       * @param start

       * @param end

       */

      public static void quickSort(int array[], int start, int end) {

            int low = start;

            int high = end;

            if (low >= end) {

                  return;

            }

            int mid = array[(low + high) / 2];

            while (low < high) {

                  while (low < high && array[low] < mid) {

                        low++;

                  }

                  while (low < high && array[high] > mid) {

                        high--;

                  }

                  if (low < high) {

                        int tmp = array[low];

                        array[low] = array[high];

                        array[high] = tmp;

                  }

            }

            if (high < low) {

                  int swap = high;

                  high = low;

                  low = swap;

            }

            quickSort(array, start, low);

            quickSort(array, low == start ? low + 1 : low, end);

      }

      /**

       * This method will sorts the array of object in ascending order which implements Comparable.

       * like String, Byte, Short, Integer, Long, Float, Double, Character,

       * Boolean, BigInteger, BigDecimal

       * @param <T>

       * @param array

       * @param start

       * @param end

       */

      public static <T extends Comparable<T>> void quickSort(T[] array, int start, int end) {

            int low = start;

            int high = end;

            if (low >= end) {

                  return;

            }

            T mid = array[(low + high) / 2];

            while (low < high) {

                  while (low < high && array[low].compareTo(mid) < 0) {

                        low++;

                  }

                  while (low < high && array[high].compareTo(mid) > 0) {

                        high--;

                  }

                  if (low < high) {

                        T tmp = array[low];

                        array[low] = array[high];

                        array[high] = tmp;

                  }

            }

            if (high < low) {

                  int swap = high;

                  high = low;

                  low = swap;

            }

            quickSort(array, start, low);

            quickSort(array, low == start ? low + 1 : low, end);

      }

      /**

       * This method will sorts the array of objects based on provided comparator in ascending order.

       * @param <T>

       * @param array

       * @param start

       * @param end

       */

      public static <T> void quickSort(T[] array, Comparator<T> comparator, int start, int end) {

            int low = start;

            int high = end;

            if (low >= end) {

                  return;

            }

            T mid = array[(low + high) / 2];

            while (low < high) {

                  while (low < high && comparator.compare(array[low], mid) < 0) {

                        low++;

                  }

                  while (low < high && comparator.compare(array[high], mid) > 0) {

                        high--;

                  }

                  if (low < high) {

                        T tmp = array[low];

                        array[low] = array[high];

                        array[high] = tmp;

                  }

            }

            if (high < low) {

                  int swap = high;

                  high = low;

                  low = swap;

            }

            quickSort(array, comparator, start, low);

            quickSort(array, comparator, low == start ? low + 1 : low, end);

      }

}