Search
 
SCRIPT & CODE EXAMPLE
 

JAVA

How to perform quick sort, in Java?


/*
	This is an implementation of the quick sort algorithm.

	Let n be the size of the list to sort
	Best: O(nlog2(n)) time | O(log2(n)) space
	Average: O(nlog2(n)) time | O(log2(n)) space
	Worst: O(n^2) time | O(log2(n)) space
*/
import java.util.Arrays;

public class QuickSort {
	public static void main(String[] args) {
		int[] arr = { 1, 10, 5, 3, 6 };
		quickSort(arr);
		// Below prints: [1, 3, 5, 6, 10]
		System.out.println(Arrays.toString(arr));
	}

	public static void quickSort(int[] array) {
		// Sort array recursively
		quickSortUtil(array, 0, array.length - 1);
	}

	private static void quickSortUtil(int[] array, int startIdx, int endIdx) {
		// Base case: at this point array is sorted
		if (startIdx >= endIdx) {
			return;
		}
		// Let first value be pivot
		// Sort every other number wrt to pivot
		int pivotIdx = startIdx;
		int leftIdx = startIdx + 1;
		int rightIdx = endIdx;
		// Make sure that element at leftIdx <= to one at pivotIdx
		// and element at rightIdx is >= to one at pivotIdx
		while (leftIdx <= rightIdx) {
			if (array[leftIdx] > array[pivotIdx] && array[rightIdx] < array[pivotIdx]) {
				swap(leftIdx, rightIdx, array);
			}
			if (array[leftIdx] <= array[pivotIdx]) {
				leftIdx++;
			}
			if (array[rightIdx] >= array[pivotIdx]) {
				rightIdx--;
			}
		}

		swap(pivotIdx, rightIdx, array);
		// At the end of current iteration, element at
		// pivot is in its final sorted position
		quickSortUtil(array, startIdx, rightIdx - 1);
		quickSortUtil(array, rightIdx + 1, endIdx);
	}

	private static void swap(int i, int j, int[] array) {
		int temp = array[i];
		array[i] = array[j];
		array[j] = temp;
	}
}
Comment

java quick sort

import java.util.Arrays;
//so fun to run//try it (;
//Illustrate array in size of 100 Million Integers 
//global arrays only!!
public class Quick {
    static int[] arr = new int[10000000];
    public static void main(String[] args) {//only use with global array!
       
        for(int i=0; i<arr.length;i++){
            arr[i]= (int)(Math.random()*1000);
        }
        quickSort(0, arr.length-1, arr[arr.length-1]);
       //(send 0 to lowi,
      //send the last index in the array to higi, 
      //send to pivot the last value in the array)
       System.out.println(Arrays.toString(arr));
         
    }
    public static void quickSort(int lowi,int higi,int pivot){
        if(higi<=lowi)
          return;
        if(higi - lowi <1)
           return;
        if(higi - lowi == 1){
            if(arr[lowi]>arr[higi])
               swap(lowi, higi);
                 return;
        }
        int temp, next = arr[lowi];
        int higiS = higi, lowiS = lowi,pos = lowi;
        
        while(higi-lowi >= 1){
            if(next<pivot){
                 temp = arr[higi];
                 if(higi == higiS)
                   temp = arr[++pos];
                 else
                   temp = arr[higi];
                
                arr[higi--] = next; 
                }
            else{
                if(lowi<=pos)
                  temp = arr[++pos];
                else
                  temp = arr[lowi];
                
                arr[lowi++] = next;
                }
                next = temp;
            }
            if(lowi<pos)
              lowi = pos-1;
      
        arr[lowi] = pivot;
        
        quickSort(lowi+1, higiS, arr[higiS]);
        if(lowi-1>=0)
        quickSort(lowiS, lowi-1, arr[lowi-1]);
 
        return;
    }
    public static void swap(int fI,int sI){
        int temp = arr[fI];
        arr[fI] = arr[sI];
        arr[sI] = temp;
    }
   
}
Comment

Quick Sort Java Implementation

// Java implementation of QuickSort
import java.io.*;
 
class GFG{
     
// A utility function to swap two elements
static void swap(int[] arr, int i, int j)
{
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}
 
/* This function takes last element as pivot, places
   the pivot element at its correct position in sorted
   array, and places all smaller (smaller than pivot)
   to left of pivot and all greater elements to right
   of pivot */
static int partition(int[] arr, int low, int high)
{
     
    // pivot
    int pivot = arr[high];
     
    // Index of smaller element and
    // indicates the right position
    // of pivot found so far
    int i = (low - 1);
 
    for(int j = low; j <= high - 1; j++)
    {
         
        // If current element is smaller
        // than the pivot
        if (arr[j] < pivot)
        {
             
            // Increment index of
            // smaller element
            i++;
            swap(arr, i, j);
        }
    }
    swap(arr, i + 1, high);
    return (i + 1);
}
 
/* The main function that implements QuickSort
          arr[] --> Array to be sorted,
          low --> Starting index,
          high --> Ending index
 */
static void quickSort(int[] arr, int low, int high)
{
    if (low < high)
    {
         
        // pi is partitioning index, arr[p]
        // is now at right place
        int pi = partition(arr, low, high);
 
        // Separately sort elements before
        // partition and after partition
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}
 
// Function to print an array
static void printArray(int[] arr, int size)
{
    for(int i = 0; i < size; i++)
        System.out.print(arr[i] + " ");
         
    System.out.println();
}
 
// Driver Code
public static void main(String[] args)
{
    int[] arr = { 10, 7, 8, 9, 1, 5 };
    int n = arr.length;
     
    quickSort(arr, 0, n - 1);
    System.out.println("Sorted array: ");
    printArray(arr, n);
}
}
 
// This code is contributed by Ayush Choudhary
Comment

java array quick sort

void selectionSort(int arr[])
{
    int n = arr.length;

    for (int i = 0; i < n-1; i++)
    {
        int min_idx = i;
        for (int j = i+1; j < n; j++)
            if (arr[j] < arr[min_idx])
                min_idx = j;

        int temp = arr[min_idx];
        arr[min_idx] = arr[i];
        arr[i] = temp;
    }
}
Comment

quick sort function java

  static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
  }  
  
  static int partition(int[] arr, int low, int high) { 
    
    int pivot = arr[high]; 
    // Index of smaller element and
    // indicates the right position
    // of pivot found so far
    int i = (low - 1); 
  
    for(int j = low; j <= high - 1; j++) {
      // If current element is smaller 
      // than the pivot
      if (arr[j] < pivot) {
        // Increment index of 
        // smaller element
        i++; 
        swap(arr, i, j);
      }
    }
    swap(arr, i + 1, high);
    return (i + 1);
  }
  
  static void quickSort(int[] arr, int low, int high) {
      if (low < high) {
          // pi is partitioning index, arr[p]
          // is now at right place 
          int pi = partition(arr, low, high);

          // Separately sort elements before
          // partition and after partition
          quickSort(arr, low, pi - 1);
          quickSort(arr, pi + 1, high);
      }
  }
Comment

quick sort java

import java.util.*;

public class Sort {
    static ArrayList<Integer> quicksort(ArrayList<Integer> list) {
        if (list.size() <= 1) {
            return list;
        }
        ArrayList<Integer> lessThanPivot = new ArrayList<Integer>();
        ArrayList<Integer> greaterThanPivot = new ArrayList<Integer>();
        int pivot = list.get(0);
        int length = list.size();
        for (int i = 1; i < length; i++) {
            int currentValue = list.get(i);
            if (currentValue <= pivot) {
                lessThanPivot.add(currentValue);
            } else {
                greaterThanPivot.add(currentValue);
            }
        }
        ArrayList<Integer> sortedList = new ArrayList<Integer>();
        sortedList.addAll(quicksort(lessThanPivot));
        sortedList.add(pivot);
        sortedList.addAll(quicksort(greaterThanPivot));
        return sortedList;
    }

    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(32, 100, 1, 2, 29, 28, 88, 3, 50, 67, 37, 1, 57, 20));
        System.out.println(quicksort(list));
    }
}
Comment

PREVIOUS NEXT
Code Example
Java :: input arraylist in java 
Java :: Syntax of Creating Java Map Objects 
Java :: syntax of the switch statement in Java 
Java :: android recyclerview pull to refresh 
Java :: int conversion to float 
Java :: binary to string java 
Java :: what is construct in java 
Java :: get string size on screen 
Java :: recyclerview adapter multiple view types 
Java :: how to check size of arrayin java 
Java :: declare matrix in java 
Java :: loops in java 
Java :: java.sql.SQLSyntaxErrorException: Unknown column 
Java :: map.put in java 
Java :: singleton 
Java :: swap two nodes of a linked list 
Java :: static method in non static class java 
Java :: wrapper classes in java ebhor.com 
Java :: Java TestNG Data Provider example 
Java :: Java try...finally block 
Java :: multiple inputs java 
Java :: @embeddedid 
Java :: how to find poiwer in java 
Java :: bukkit api listener 
Java :: how to display an integer in a textfield in java 
Java :: remove character stringbuffer 
Java :: grava 
Java :: how to install openjdk 16 
Java :: find if element is powers of 2 
Java :: android bootom app bar tab bar 
ADD CONTENT
Topic
Content
Source link
Name
8+7 =