Friday, April 22, 2016

ArrayLists and Lists

Lists and ArrayLists in Java programming are objects that store other objects inside of them, they are very useful for storing data in multiple levels.
A usual object can store data inside of it as well as objects but ArrayLists keep the data organized in a deeper level. They are somewhat like normal arrays (String[]) however they are elastic instead of solid, meaning that they can increase and decrease in size depending on how much is required, instead of in a set amount.

public static void main(String[]args){

ArrayList<String> names = new ArrayList();// This is an example of instantiating an array list
List<String> moreNames = new ArrayList();//Lists and ArrayLists are similar however ArrayLists //are child objects from the List class. Thus the ArrayList class contains all of the previous methods //and more.

names.add("Joseph");//This is how to add a new object to an array list, it returns a boolean: true;
names.add(0, "Edward");//This adds a new object in the place of what ever is located in the index 
           //and moves the object in that index to the index higher than itself
           // The array will end up as: Edward, Joseph.
names.remove(1);//This removes an object from the array and and if it is larger than the index it //moves all objects after it downward an index unit, it also returns the object.

for(String n: names){System.out.print(n + " ");}//This will print in the console the objects in the list:
// Edward Smigla


Thursday, April 7, 2016

Sorting: Quick Sort

Quick sort is a divide and conquer approach to sorting just like Merge sort, however this method is more efficient but it does take up more memory space.
The method divides a list of integers, picks an integer of an array to be a pivot, then moves the integers that are larger in value and moves it to the right of the pivot, and then does that to the smaller ones.

Quick Sort
public class MyQuickSort {
    private int array[];
    private int length;
    public void sort(int[] inputArr) {
        if (inputArr == null || inputArr.length == 0) {
        this.array = inputArr;
        length = inputArr.length;
        quickSort(0, length - 1);
    private void quickSort(int lowerIndex, int higherIndex) {
        int i = lowerIndex;
        int j = higherIndex;
        // calculate pivot number, I am taking pivot as middle index number
        int pivot = array[lowerIndex+(higherIndex-lowerIndex)/2];
        // Divide into two arrays
        while (i <= j) {
             * In each iteration, we will identify a number from left side which
             * is greater then the pivot value, and also we will identify a number
             * from right side which is less then the pivot value. Once the search
             * is done, then we exchange both numbers.
            while (array[i] < pivot) {
            while (array[j] > pivot) {
            if (i <= j) {
                exchangeNumbers(i, j);
                //move index to next position on both sides
        // call quickSort() method recursively
        if (lowerIndex < j)
            quickSort(lowerIndex, j);
        if (i < higherIndex)
            quickSort(i, higherIndex);
    private void exchangeNumbers(int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    public static void main(String a[]){
        MyQuickSort sorter = new MyQuickSort();
        int[] input = {24,2,45,20,56,75,2,56,99,53,12};
        for(int i:input){
            System.out.print(" ");