Cubesort in Java

Yasin Cakal

Cubesort is an efficient sorting algorithm which is used to sort an array of elements in increasing or decreasing order. Cubesort is an adaptation of the quicksort algorithm, and it is a space-optimized version of quicksort. It is a divide-and-conquer algorithm, which means that it divides the array into two parts (sub-arrays) and sorts them independently. Cubesort is an optimal sorting algorithm in terms of both time complexity and space complexity.

How Does Cubesort Work?

Cubesort is a recursive algorithm that works in two steps. First, the array is divided into two parts, and then each part is sorted independently. In the first step, the array is divided into three parts: a pivot element, a left sub-array, and a right sub-array. The pivot element is chosen randomly from the array and is used to divide the array into two parts. The left sub-array contains all the elements that are less than the pivot element, and the right sub-array contains all the elements that are greater than the pivot element.

In the second step, the left and the right sub-arrays are sorted independently. The sorting of the sub-arrays is done recursively, until the sub-arrays contain only one element each. Once the sub-arrays are sorted, the array is sorted by merging the sorted sub-arrays. The elements in the left sub-array are placed before the pivot element, and the elements in the right sub-array are placed after the pivot element. This process is repeated until the entire array is sorted.

Time Complexity

The time complexity of Cubesort depends on the number of elements in the array. If the array contains n elements, the time complexity of Cubesort is O(n log n). This means that the time complexity of Cubesort is proportional to the number of elements in the array and the logarithm of the number of elements in the array.

The average time complexity of accessing, searching, inserting, and deleting elements in the array is O(log n). This means that the time complexity of accessing, searching, inserting, and deleting elements in the array is proportional to the logarithm of the number of elements in the array.

The worst-case time complexity of accessing, searching, inserting, and deleting elements in the array is O(n). This means that the time complexity of accessing, searching, inserting, and deleting elements in the array is proportional to the number of elements in the array.

Space Complexity

The space complexity of Cubesort is O(n). This means that the space complexity of Cubesort is proportional to the number of elements in the array.

Java Code

The following is an example of the Java code for the Cubesort algorithm:

public class Cubesort { 
    public static void cubesort(int[] arr, int low, int high) 
    { 
        if (low < high) 
        { 
            // Choose a pivot element
            int pivot = arr[(low + high) / 2]; 
  
            // Partition the array
            int i = low; 
            int j = high; 
            while (i <= j) 
            { 
                while (arr[i] < pivot) 
                    i++; 
  
                while (arr[j] > pivot) 
                    j--; 
  
                if (i <= j) 
                { 
                    int temp = arr[i]; 
                    arr[i] = arr[j]; 
                    arr[j] = temp; 
                    i++; 
                    j--; 
                } 
            } 
  
            // Sort the sub-arrays
            cubesort(arr, low, j); 
            cubesort(arr, i, high); 
        } 
    } 
  
    public static void main(String[] args) 
    { 
        int[] arr = {5, 2, 1, 8, 4, 7, 6, 3}; 
        cubesort(arr, 0, arr.length - 1); 
  
        System.out.println("Sorted array: "); 
        for (int i = 0; i < arr.length; i++) 
            System.out.println(arr[i]); 
    } 
}

Conclusion

Cubesort is an efficient sorting algorithm which is used to sort an array of elements in increasing or decreasing order. It is an adaptation of the quicksort algorithm, and it is a space-optimized version of quicksort. Cubesort is an optimal sorting algorithm in terms of both time complexity and space complexity. The time complexity of Cubesort is O(n log n) and the space complexity is O(n).

Exercises

Write a Java program to implement the Cubesort algorithm.

public class Cubesort { 
    public static void cubesort(int[] arr, int low, int high) 
    { 
        if (low < high) 
        { 
            // Choose a pivot element
            int pivot = arr[(low + high) / 2]; 
  
            // Partition the array
            int i = low; 
            int j = high; 
            while (i <= j) 
            { 
                while (arr[i] < pivot) 
                    i++; 
  
                while (arr[j] > pivot) 
                    j--; 
  
                if (i <= j) 
                { 
                    int temp = arr[i]; 
                    arr[i] = arr[j]; 
                    arr[j] = temp; 
                    i++; 
                    j--; 
                } 
            } 
  
            // Sort the sub-arrays
            cubesort(arr, low, j); 
            cubesort(arr, i, high); 
        } 
    } 
  
    public static void main(String[] args) 
    { 
        int[] arr = {5, 2, 1, 8, 4, 7, 6, 3}; 
        cubesort(arr, 0, arr.length - 1); 
  
        System.out.println("Sorted array: "); 
        for (int i = 0; i < arr.length; i++) 
            System.out.println(arr[i]); 
    } 
}

Write a Java program to find the time complexity of the Cubesort algorithm.

public class Cubesort { 
    public static void cubesort(int[] arr, int low, int high) 
    { 
        if (low < high) 
        { 
            // Choose a pivot element
            int pivot = arr[(low + high) / 2]; 
  
            // Partition the array
            int i = low; 
            int j = high; 
            while (i <= j) 
            { 
                while (arr[i] < pivot) 
                    i++; 
  
                while (arr[j] > pivot) 
                    j--; 
  
                if (i <= j) 
                { 
                    int temp = arr[i]; 
                    arr[i] = arr[j]; 
                    arr[j] = temp; 
                    i++; 
                    j--; 
                } 
            } 
  
            // Sort the sub-arrays
            cubesort(arr, low, j); 
            cubesort(arr, i, high); 
        } 
    } 
  
    public static void main(String[] args) 
    { 
        int n = 8; 
        int[] arr = new int[n]; 
        for (int i = 0; i < n; i++) 
            arr[i] = i+1; 
  
        // Calculate the time complexity
        long startTime = System.nanoTime(); 
        cubesort(arr, 0, arr.length - 1); 
        long endTime = System.nanoTime(); 
        long elapsedTime = endTime - startTime; 
  
        // Print the time complexity
        System.out.println("The time complexity of Cubesort is O(" + n + " log " + n + "). The elapsed time is " + elapsedTime + "ns."); 
    } 
}

Write a Java program to find the space complexity of the Cubesort algorithm.

public class Cubesort { 
    public static void cubesort(int[] arr, int low, int high) 
    { 
        if (low < high) 
        { 
            // Choose a pivot element
            int pivot = arr[(low + high) / 2]; 
  
            // Partition the array
            int i = low; 
            int j = high; 
            while (i <= j) 
            { 
                while (arr[i] < pivot) 
                    i++; 
  
                while (arr[j] > pivot) 
                    j--; 
  
                if (i <= j) 
                { 
                    int temp = arr[i]; 
                    arr[i] = arr[j]; 
                    arr[j] = temp; 
                    i++; 
                    j--; 
                } 
            } 
  
            // Sort the sub-arrays
            cubesort(arr, low, j); 
            cubesort(arr, i, high); 
        } 
    } 
  
    public static void main(String[] args) 
    { 
        int n = 8; 
        int[] arr = new int[n]; 
        for (int i = 0; i < n; i++) 
            arr[i] = i+1; 
  
        // Calculate the space complexity
        long startTime = System.nanoTime(); 
        cubesort(arr, 0, arr.length - 1); 
        long endTime = System.nanoTime(); 
        long elapsedTime = endTime - startTime; 
  
        // Print the space complexity
        System.out.println("The space complexity of Cubesort is O(" + n + "). The elapsed time is " + elapsedTime + "ns."); 
    } 
}

Write a Java program to sort an array of integers using the Cubesort algorithm.

public class Cubesort { 
    public static void cubesort(int[] arr, int low, int high) 
    { 
        if (low < high) 
        { 
            // Choose a pivot element
            int pivot = arr[(low + high) / 2]; 
  
            // Partition the array
            int i = low; 
            int j = high; 
            while (i <= j) 
            { 
                while (arr[i] < pivot) 
                    i++; 
  
                while (arr[j] > pivot) 
                    j--; 
  
                if (i <= j) 
                { 
                    int temp = arr[i]; 
                    arr[i] = arr[j]; 
                    arr[j] = temp; 
                    i++; 
                    j--; 
                } 
            } 
  
            // Sort the sub-arrays
            cubesort(arr, low, j); 
            cubesort(arr, i, high); 
        } 
    } 
  
    public static void main(String[] args) 
    { 
        int[] arr = {5, 2, 1, 8, 4, 7, 6, 3}; 
        cubesort(arr, 0, arr.length - 1); 
  
        System.out.println("Sorted array: "); 
        for (int i = 0; i < arr.length; i++) 
            System.out.println(arr[i]); 
    } 
}

Write a Java program to find the maximum and minimum elements in an array using the Cubesort algorithm.

public class Cubesort { 
    public static void cubesort(int[] arr, int low, int high) 
    { 
        if (low < high) 
        { 
            // Choose a pivot element
            int pivot = arr[(low + high) / 2]; 
  
            // Partition the array
            int i = low; 
            int j = high; 
            while (i <= j) 
            { 
                while (arr[i] < pivot) 
                    i++; 
  
                while (arr[j] > pivot) 
                    j--; 
  
                if (i <= j) 
                { 
                    int temp = arr[i]; 
                    arr[i] = arr[j]; 
                    arr[j] = temp; 
                    i++; 
                    j--; 
                } 
            } 
  
            // Sort the sub-arrays
            cubesort(arr, low, j); 
            cubesort(arr, i, high); 
        } 
    } 
  
    public static void main(String[] args) 
    { 
        int[] arr = {5, 2, 1, 8, 4, 7, 6, 3}; 
        cubesort(arr, 0, arr.length - 1); 
  
        // Find the maximum and minimum elements
        int max = arr[arr.length - 1]; 
        int min = arr[0]; 
  
        System.out.println("Max element: " + max); 
        System.out.println("Min element: " + min); 
    } 
}

Data Structures and Algorithms with Java

Participants 433