Bi-Directional Bubble Sort Implementation in Java

[Note: This article was originally published in my another blog and has been migrated over here]

Definition:
Cocktail sort, also known as bidirectional bubble sort, cocktail shaker sort, shaker sort (which can also refer to a variant of selection sort), ripple sort, shuttle sort or happy hour sort, is a variation of bubble sort that is both a stable sorting algorithm and a comparison sort. The algorithm differs from bubble sort in that sorts in both directions each pass through the list. This sorting algorithm is only marginally more difficult than bubble sort to implement, and solves the problem with so-called turtles in bubble sort.

Differences From Bubble Sort:
Cocktail sort is a slight variation of bubble sort. It differs in that instead of repeatedly passing through the list from bottom to top, it passes alternately from bottom to top and then from top to bottom. It can achieve slightly better performance than a standard bubble sort. The reason for this is that bubble sort only passes through the list in one direction and therefore can only move items backward one step each iteration.

An example of a list that proves this point is the list (2,3,4,5,1), which would only need to go through one pass of cocktail sort to become sorted, but if using an ascending bubble sort would take four passes. However one cocktail sort pass should be counted as two bubble sort passes. Typically cocktail sort is less than two times faster than bubble sort.

Another optimization can be that the algorithm remembers where the last actual swap has been done. In the next iteration, there will be no swaps beyond this limit and the algorithm has shorter passes. As the Cocktail sort goes bidirectionally, the range of possible swaps, which is the range to be tested, will reduce per pass, thus reducing the overall running time.

[Source of above Text: Wikipedia.

The following is my implementation of Bidirectional Bubble Sort in Java.

```/**
* BidirectionalBubbleSort.java
*
* Author: Kushal Paudyal
* www.icodejava.com
*
*/
package com.kushal.sort;

public class BidirectionalBubbleSort {

/**
* The bidirectional bubble sort method that takes
* an array of unsorted integers, sorts them and
* returns a sorted array.
*/
public static int[] bidirectionalBubbleSort(int array[]) {
int length = array.length;
int j;
int st = -1;
while (st &lt; length) {
st++;
length--;
for (j = st; j &lt; length; j++) {
if (array[j] &gt; array[j + 1]) {
swap(array, j, j + 1);
}
}
for (j = length; --j &gt;= st;) {
if (array[j] &gt; array[j + 1]) {
swap(array, j, j + 1);
}
}
}
return array;
}

/**
* Swapping The Elements at two different indexes of an Arary
*/
private static void swap(int[] anArray, int firstIndex, int secondIndex) {
int temp = anArray[firstIndex];
anArray[firstIndex] = anArray[secondIndex];
anArray[secondIndex] = temp;
}

/**
* Method to print the content of any array.
*/
public static void printArray(int[] array) {
for (int i = 0; i &lt; array.length; i++)
System.out.print(array[i] + "  ");

System.out.println();
}

/**
* Testing the bidirectional bubble sort with some sample unsorted array of
* integers
*/
public static void main(String a[]) {
int unsortedArray[] = { 121, 79, 24, 190, 203, 1, 33, 110 };

System.out.print("Unsorted: \t");
printArray(unsortedArray);

int[] sortedArray = bidirectionalBubbleSort(unsortedArray);
System.out.print("Sorted: \t");
printArray(sortedArray);

}
/*
* SANJAAL CORPS MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
* THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
* TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
* PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SANJAAL CORPS SHALL NOT BE LIABLE FOR
* ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
* DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
*
* THIS SOFTWARE IS NOT DESIGNED OR INTENDED FOR USE OR RESALE AS ON-LINE
* CONTROL EQUIPMENT IN HAZARDOUS ENVIRONMENTS REQUIRING FAIL-SAFE
* PERFORMANCE, SUCH AS IN THE OPERATION OF NUCLEAR FACILITIES, AIRCRAFT
* NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL, DIRECT LIFE
* SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH THE FAILURE OF THE
* SOFTWARE COULD LEAD DIRECTLY TO DEATH, PERSONAL INJURY, OR SEVERE
* PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH RISK ACTIVITIES"). SANJAAL CORPS
* SPECIFICALLY DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR
* HIGH RISK ACTIVITIES.
*/
}
```

=========================
Sample Output

```Unsorted:     121  79  24  190  203  1  33  110
Sorted:     1  24  33  79  110  121  190  203
```

Java Code Implementation Of Selection Sort

Selection sort is a sorting algorithm, specifically an in-place comparison sort. It has O(n^2) complexity, making it inefficient on large lists, and generally performs worse than the similar insertion sort. Selection sort is noted for its simplicity, and also has performance advantages over more complicated algorithms in certain situations.

The algorithm works as follows:

1. Find the minimum value in the list
2. Swap it with the value in the first position
3. Repeat the steps above for the remainder of the list (starting at the second position and advancing each time)

Effectively, we divide the list into two parts: the sublist of items already sorted, which we build up from left to right and is found at the beginning, and the sublist of items remaining to be sorted, occupying the remainder of the array.

Selection sort can also be used on list structures that make add and remove efficient, such as a linked list. In this case it’s more common to remove the minimum element from the remainder of the list, and then insert it at the end of the values sorted so far.

Variants of Selection Sort:
Heapsort greatly improves the basic algorithm by using an implicit heap data structure to speed up finding and removing the lowest datum. If implemented correctly, the heap will allow finding the next lowest element in T(log n) time instead of T(n) for the inner loop in normal selection sort, reducing the total running time to T(n log n).

A bidirectional variant of selection sort, called cocktail sort, is an algorithm which finds both the minimum and maximum values in the list in every pass. This reduces the number of scans of the list by a factor of 2, eliminating some loop overhead but not actually decreasing the number of comparisons or swaps. Note, however, that cocktail sort more often refers to a bidirectional variant of bubble sort.

Selection sort can be implemented as a stable sort. If, rather than swapping in step 2, the minimum value is inserted into the first position (that is, all intervening items moved down), the algorithm is stable. However, this modification either requires a data structure that supports efficient insertions or deletions, such as a linked list, or it leads to performing T(n^2) writes. Either way, it eliminates the main advantage of insertion sort (which is always stable) over selection sort.

In the bingo sort variant, items are ordered by repeatedly looking through the remaining items to find the greatest value and moving all items with that value to their final location. Like counting sort, this is an efficient variant if there are many duplicate values. Indeed, selection sort does one pass through the remaining items for each item moved. Bingo sort does two passes for each value (not item): one pass to find the next biggest value, and one pass to move every item with that value to its final location. Thus if on average there are more than two items with each value, bingo sort may be faster.

(Source Of The Above Text: Wikipedia
———————————-

The following is my implementation of Selection Sort in Java.

Sorted Circular Linked List Implementation And Insert Operation

Circular Linked List Data Structure (Unsorted). Source: Wikipedia

Circular Linked List is a kind of Linked List where the elements are accessed sequentially and the last node of the sequence points back to the first node, thus creating a circle. Circular linked lists can be created with simple Java Objects. The only tricky portion is to understand how to link the next element.

The following piece of code demonstrates:

1. How to create a circular linked list data structure
2. How to insert elements to the list so that the insertion creates a sorted data structure.
3. How to handle special scenarios such as:
• Inserting to an empty list
• Inserting duplicate elements
• Inserting element greater than tail (thus forming new tail)
• Inserting element in between two elements.

```package com.icodejava.blog.datastructure;
/**
* @author Kushal Paudyal
* www.icodejava.com
* Created On -  Feb 22, 2014
*/
public class CircularListInsert {
public static void main(String args[]) {

CircularList myList = new CircularList(5);
myList.printAll();

myList = myList.insert(2);
myList.printAll();

//test for value smaller than the head.
myList = myList.insert(1);
myList.printAll();

myList = myList.insert(3);
myList.printAll();

//Test for duplicate value
myList = myList.insert(5);
myList.printAll();

//test for value greater than he tail.
myList = myList.insert(6);
myList.printAll();
}
}

class CircularList {
CircularList next;
int value;

public CircularList(int value) {
this.next = this;
this.value = value;
}

/**
* @param value
*            - new value to be inserted in the list.
* @return head node in the circular list
*
* This method inserts data in ascending order.
*/
public CircularList insert(int value) {

// if the current list is null.
if (this == null) {
return new CircularList(value);
} else if (this.next == this) {
// if the current list is head and tail i.e. single element
this.next = new CircularList(value);
this.next.next = this;

// return the smallest node as the head
if (this.value < value) {
return this;
} else {
return this.next;
}
} else if (value < this.value) {

// if the value is smaller than the head
// find the tail and append.

CircularList temp = new CircularList(value);
temp.next = this;

CircularList current = this.next;
while (current.next != this) {
current = current.next;
}

current.next = new CircularList(value);
current.next.next = this;

return current.next;

} else if (value >= this.value) {
CircularList current = this;

/**
* Keep looking for nodes until all the nodes are smaller than the
* value to be inserted.
*/
while (current.next != this && current.next.value <= value) {
current = current.next;
}

/**
* Once we find the node to be inserted, make a copy of the
* current's next value. Insert a node as current's next. and Make
* current's next's next value as the previous next which has been
* copied as temp
*/
CircularList temp = current.next;
current.next = new CircularList(value);
current.next.next = temp;
return this;

}

return this;
}

public void printAll() {

if (this == null) {
return;
}

CircularList current = this;

do {

System.out.print(current.value + ",");
current = current.next;
} while (current != this);

System.out.println();
}
}
```

The output of running this program is below. Please note that the elements appear sorted.

```5,
2,5,
1,2,5,
1,2,3,5,
1,2,3,5,5,
1,2,3,5,5,6,
```