Algorithms for searching and sorting

In this part we will apply what we have learned about algorithms using the example of searching within data structures and sorting lists.

In [1]:
import java.util.List; 

// linear search over an unsorted list
List<Integer> l = List.of(1,5,43,23,3,6,13);
int e = 6;

for(Integer i: l)
    if (e == i)
        return true;


return false;
Out[1]:
true
In [23]:
package lecture;

import java.util.List;

public class BinarySearch {
    
    public static boolean search(List l, int e) {
        System.out.println("\n\n----- search for " + e + " ------");
        return binSearch(l, e, 0, l.size() - 1);
    }
    
    private static boolean binSearch(List<Integer> l, int e, int low, int high) {
        int mid = (low + high) / 2;
        System.out.printf("searching for %d [%d,%d,%d]\n", e, low, mid, high);
        if (low > high)
            return false;
        if (e == l.get(mid))
            return true;
        else if (e < l.get(mid))
            return binSearch(l, e, low, mid - 1);
        else // (e > l.get(mid))
            return binSearch(l, e, mid + 1, high);
    }   
}
Out[23]:
lecture.BinarySearch
In [24]:
import java.util.List;
import lecture.BinarySearch;

List<Integer> l = List.of(1,4,6,7,9,10,13,22,24); // list has to be sorted for binary search

System.out.println("\nIs 1 in list: " + BinarySearch.search(l, 1));
System.out.println("\nIs 4 in list: " + BinarySearch.search(l, 4));
System.out.println("\nIs 5 in list: " + BinarySearch.search(l, 5));
System.out.println("\nIs 7 in list: " + BinarySearch.search(l, 7));
System.out.println("\nIs 9 in list: " + BinarySearch.search(l, 9));
System.out.println("\nIs 10 in list: " + BinarySearch.search(l, 10));
System.out.println("\nIs 13 in list: " + BinarySearch.search(l, 13));
System.out.println("\nIs 22 in list: " + BinarySearch.search(l, 22));
System.out.println("\nIs 24 in list: " + BinarySearch.search(l, 24));

System.out.println("\nIs 0 in list: " + BinarySearch.search(l, 0));
System.out.println("\nIs 11 in list: " + BinarySearch.search(l, 11));
System.out.println("\nIs 50 in list: " + BinarySearch.search(l, 50));


----- search for 1 ------
searching for 1 [0,4,8]
searching for 1 [0,1,3]
searching for 1 [0,0,0]

Is 1 in list: true


----- search for 4 ------
searching for 4 [0,4,8]
searching for 4 [0,1,3]

Is 4 in list: true


----- search for 5 ------
searching for 5 [0,4,8]
searching for 5 [0,1,3]
searching for 5 [2,2,3]
searching for 5 [2,1,1]

Is 5 in list: false


----- search for 7 ------
searching for 7 [0,4,8]
searching for 7 [0,1,3]
searching for 7 [2,2,3]
searching for 7 [3,3,3]

Is 7 in list: true


----- search for 9 ------
searching for 9 [0,4,8]

Is 9 in list: true


----- search for 10 ------
searching for 10 [0,4,8]
searching for 10 [5,6,8]
searching for 10 [5,5,5]

Is 10 in list: true


----- search for 13 ------
searching for 13 [0,4,8]
searching for 13 [5,6,8]

Is 13 in list: true


----- search for 22 ------
searching for 22 [0,4,8]
searching for 22 [5,6,8]
searching for 22 [7,7,8]

Is 22 in list: true


----- search for 24 ------
searching for 24 [0,4,8]
searching for 24 [5,6,8]
searching for 24 [7,7,8]
searching for 24 [8,8,8]

Is 24 in list: true


----- search for 0 ------
searching for 0 [0,4,8]
searching for 0 [0,1,3]
searching for 0 [0,0,0]
searching for 0 [0,0,-1]

Is 0 in list: false


----- search for 11 ------
searching for 11 [0,4,8]
searching for 11 [5,6,8]
searching for 11 [5,5,5]
searching for 11 [6,5,5]

Is 11 in list: false


----- search for 50 ------
searching for 50 [0,4,8]
searching for 50 [5,6,8]
searching for 50 [7,7,8]
searching for 50 [8,8,8]
searching for 50 [9,8,8]

Is 50 in list: false
Out[24]:
null
In [31]:
package lecture;

public class QuickSort {
    
    public static void sort(int[] l) {
        qsort(l, 0, l.length - 1);
    }
    
    private static void qsort(int[] l, int low, int high) {
        if (low < high) {
            int mid = partition(l, low, high);
            qsort(l, low, mid - 1);
            qsort(l, mid + 1, high);
        }
    }
    
    private static void swap(int[] l, int left, int right) {
        int temp = l[left];
        l[left] = l[right];
        l[right] = temp;
    }
    
    private static int partition(int[] l, int low, int high) {
        int p = l[high]; // choose last element as pivot
        while(low < high) {
            if (l[low] > p)
                swap(l, low, high--);
            else
                low++;
        }
        return low;
    }
    
}
Out[31]:
lecture.QuickSort
In [43]:
package lecture;

public class BubbleSort {
    
    public static void sort(int[] l) {
        for(int i = 0; i < l.length - 1; i++) {
            for(int j = i+1; j < l.length; j++) {
                if (l[j-1] > l[j]) {
                    int temp = l[j-1];
                    l[j-1] = l[j];
                    l[j] = temp;
                }
            }
        }
    }
}
Out[43]:
lecture.BubbleSort
In [45]:
package lecture;

public class SelectionSort {

    public static void sort(int[] l) {
        for(int i = 0; i < l.length - 1; i++) {
            int min = l[i];
            int pos = i;
            
            for(int j = i+1; j < l.length; j++) {
                if(l[j] < min) {
                    min = l[j];
                    pos = j;
                }
            }
            swap(l, i, pos);
        }
    }
    
    private static void swap(int[] l, int left, int right) {
        int temp = l[left];
        l[left] = l[right];
        l[right] = temp;
    }
    

}
Out[45]:
lecture.SelectionSort
In [37]:
import java.util.List;
import java.util.Arrays;
import lecture.QuickSort;

int[] l = { 1,4,24, 3, 9, 7, 100, 65, 64 }; // list has to be sorted for binary search

QuickSort.sort(l);

return Arrays.toString(l);
Out[37]:
[1, 3, 7, 4, 9, 24, 64, 65, 100]
In [38]:
import java.util.List;
import java.util.Arrays;
import lecture.BubbleSort;

int[] l = { 1,4,24, 3, 9, 7, 100, 65, 64 }; // list has to be sorted for binary search

BubbleSort.sort(l);

return Arrays.toString(l);
Out[38]:
[1, 3, 4, 7, 9, 24, 64, 65, 100]
In [46]:
import java.util.List;
import java.util.Arrays;
import lecture.SelectionSort;

int[] l = { 1,4,24, 3, 9, 7, 100, 65, 64 }; // list has to be sorted for binary search

SelectionSort.sort(l);

return Arrays.toString(l);
Out[46]:
[1, 3, 4, 7, 9, 24, 64, 65, 100]
In [52]:
import java.util.Arrays;
import java.util.Random;
import lecture.QuickSort;
import lecture.BubbleSort;

Random r = new Random();
int[] l = new int[100000];

for(int i = 0; i < l.length; i++)
    l[i] = r.nextInt();
System.out.println("Quicksort start");
QuickSort.sort(l);
System.out.println("Quicksort end");

for(int i = 0; i < l.length; i++)
    l[i] = r.nextInt();
System.out.println("Bubblesort start");
BubbleSort.sort(l);
System.out.println("Bubblesort end");

return null;

Quicksort start
Quicksort end
Bubblesort start
Bubblesort end
Out[52]:
null