Balanced String

A program to determine if the parentheses (), the brackets [], and the braces {}, in a string are balanced.

For example:

{{)(}} is not balanced because ) comes before (

({)} is not balanced because) is not balanced between {} and similarly the { is not balanced between ()

[({})] is balanced

{}([]) is balanced

{()}[[{}]] is balanced

import java.util.Stack;

public class BalancedParenthesis {

     public static void main(String[] args) {

          BalancedParenthesis bp = new BalancedParenthesis();

          System.out.println(bp.isBalanced("{{)(}}"));

          System.out.println(bp.isBalanced("({)}"));

          System.out.println(bp.isBalanced("[({})]"));

          System.out.println(bp.isBalanced("{}([])"));

          System.out.println(bp.isBalanced("{()}[[{}]]"));

     }

     public boolean isBalanced(String string) {

          Stack stack = new Stack<>();

          for (String token : string.split("")) {

               if ("(".equals(token) || "[".equals(token) || "{".equals(token)) {

                    stack.push(token);

               } else if (")".equals(token) || "]".equals(token) || "}".equals(token)) {

                    if (stack.isEmpty()) {

                         return false;

                    }

                    String pop = stack.pop();

                    if ((")".equals(token) && !"(".equals(pop))

                              || ("]".equals(token) && !"[".equals(pop))

                              || ("}".equals(token) && !"{".equals(pop))) {

                         return false;

                    }

               }

          }

          return true;

     }

}

Output:

false

false

true

true

true

MyStack (LIFO) : Stack implementation with Array and Generics

MyStack.java:

package com.lnn.ds.stack;

import java.util.Objects;

public class MyStack<T> {

      private T[] data;

      private int size = -1;

      private int capacity;

      @SuppressWarnings("unchecked")

      public MyStack(int capacity) {

            this.capacity = capacity;

            this.data = (T[]) new Object[capacity];

      }

      public boolean isFull() {

            return (size + 1 == capacity);

      }

      public boolean isEmpty() {

            return (size == -1);

      }

      public T pop() {

            if (!isEmpty()) {

                  return data[size--];

            }

            return null;

      }

      public boolean push(T element) {

            if (!isFull()) {

                  data[++size] = element;

                  return true;

            }

            return false;

      }

      public boolean search(T element) {

            for (int i = 0; i <= size; i++) {

                  if (Objects.equals(data[i], element)) {

                        return true;

                  }

            }

            return false;

      }

      public String toString() {

            StringBuilder builder = new StringBuilder();

            builder.append("[");

            for (int i = 0; i <= size; i++) {

                  builder.append(data[i]);

                  if (i < size) {

                        builder.append(", ");

                  }

            }

            builder.append("]");

            return builder.toString();

      }

}

MyStackTest.java:

package com.lnn.ds.stack;

public class MyStackTest {

      public static void main(String[] args) {

            MyStack<Integer> stack = new MyStack<Integer>(10);

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

                  stack.push(i);

            }

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

                  System.out.println(stack);

                  stack.pop();

            }

      }

}

MyStack (LIFO) : Implemented with Generics

MyStack.java:

package com.lnn.ds.stack;

import java.util.Objects;

public class MyStack<T> {

      private static class Node<T> {

            private Node<T> prev;

            private T data;

            public Node(T data) {

                  this.data = data;

            }

            public T getData() {

                  return data;

            }

            public Node<T> getPrev() {

                  return prev;

            }

            public void setPrev(Node<T> prev) {

                  this.prev = prev;

            }

            public String toString() {

                  return String.valueOf(getData());

            }

      }

      private Node<T> tail;

      public boolean isEmpty() {

            return (tail == null);

      }

      public boolean pop() {

            if (tail != null) {

                  Node<T> tmp = tail.getPrev();

                  setTail(tmp);

                  return true;

            }

            return false;

      }

      public void push(T data) {

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

            next.setPrev(tail);

            setTail(next);

      }

      public boolean search(T data) {

            Node<T> tmp = tail;

            while (tmp != null) {

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

                        return true;

                  }

                  tmp = tmp.getPrev();

            }

            return false;

      }

      private void setTail(Node<T> tail) {

            this.tail = tail;

      }

      public String toString() {

            StringBuilder builder = new StringBuilder();

            builder.append("[");

            Node<T> tmp = tail;

            while (tmp != null) {

                  builder.append(tmp.getData());

                  tmp = tmp.getPrev();

                  if (tmp != null) {

                        builder.append(", ");

                  }

            }

            builder.append("]");

            return builder.toString();

      }

}

MyStackTest.java:

package com.lnn.ds.stack;

public class MyStackTest {

      public static void main(String[] args) {

            MyStack<Integer> stack = new MyStack<Integer>();

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

                  stack.push(i);

            }

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

                  System.out.println(stack);

                  stack.pop();

            }

      }

}