Breaking News: Grepper is joining You.com. Read the official announcement!

Quick Sort Java Implementation

Add Answer

Stupid Scarab answered on April 26, 2021 Popularity 9/10 Helpfulness 3/10

answer Quick Sort Java Implementation

related avif to png

related How to perform quick sort, in Java?

related java quick sort

related quicksort java

related avif to png

related java array quick sort

related quicksort java

related avif to png

related quick sort java

Quick Sort Java Implementation

Comment

// 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

Popularity 9/10 Helpfulness 3/10 Language java

Source: www.geeksforgeeks.org

Tags: implementation java

Link to this answer
Share Copy Link

Contributed on Mar 10 2022

Stupid Scarab

0 Answers Avg Quality 2/10

Closely Related Answers

avif to png

Comment

what the fuck is an avif?

who though of an avif, what is an avif, why do we use avifs. fuck avifs

Popularity 10/10 Helpfulness 4/10 Language whatever

Source: Grepper

Tags: avif

Link to this answer
Share Copy Link

Contributed on May 13 2023

Soot Hoot Moon Croot

0 Answers Avg Quality 2/10

How to perform quick sort, in Java?

Comment

/*
	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;
	}
}

Popularity 9/10 Helpfulness 4/10 Language java

Source: Grepper

Tags: java

Link to this answer
Share Copy Link

Contributed on May 26 2022

Wissam

0 Answers Avg Quality 2/10

java quick sort

Comment

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;
    }
   
}

Popularity 9/10 Helpfulness 4/10 Language java

Source: Grepper

Tags: java

Link to this answer
Share Copy Link

Contributed on May 06 2022

Elegant Elephant

0 Answers Avg Quality 2/10

quicksort java

Comment

//GOD's quicksort
public static <E extends Comparable<E>> List<E> sort(List<E> col) {
  if (col == null || col.isEmpty())
    return Collections.emptyList();
  else {
    E pivot = col.get(0);
    Map<Integer, List<E>> grouped = col.stream()
      .collect(Collectors.groupingBy(pivot::compareTo));
    return Stream.of(sort(grouped.get(1)), grouped.get(0), sort(grouped.get(-1)))
      .flatMap(Collection::stream).collect(Collectors.toList());
  }
}

Popularity 10/10 Helpfulness 3/10 Language java

Source: rosettacode.org

Tags: java

Link to this answer
Share Copy Link

Contributed on Apr 26 2021

Yellowed Yacare

0 Answers Avg Quality 2/10

avif to png

Comment

Let me guess, you downloaded avif image from unsplash

Popularity 9/10 Helpfulness 2/10 Language whatever

Source: Grepper

Tags: avif

Link to this answer
Share Copy Link

Contributed on Oct 10 2024

Gleaming Goosander

0 Answers Avg Quality 2/10

java array quick sort

Comment

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;
    }
}

Popularity 8/10 Helpfulness 2/10 Language java

Source: www.sortvisualizer.com

Tags: java

Link to this answer
Share Copy Link

Contributed on Jun 12 2022

Homeless Hummingbird

0 Answers Avg Quality 2/10

quicksort java

Comment

import java.util.Random;

public class main{
public static void main(String[] args) {
    Random rand=new Random();
    int[]numbers=new int[60000000];
    for (int i = 0; i < numbers.length; i++) {
        numbers[i]=rand.nextInt(10000);
    }
    System.out.println("before");
    quickSort(numbers);
    System.out.println("after");
   // printArray(numbers);
    
}
static void printArray(int []numbers){
    for(int x:numbers){
        System.out.println(x);
    }
}
static void quickSort(int[]numbers){
    quickSort(numbers,0,numbers.length-1);
}
static void quickSort(int[]numbers,int lowIndex,int heighIndex){
if(lowIndex>=heighIndex)return;
int pivotIndex=new Random().nextInt(heighIndex-lowIndex)+lowIndex;
int pivot=numbers[pivotIndex];
int leftPointer=lowIndex;
int righPointer=heighIndex;
swap(numbers, pivotIndex, heighIndex);
while(leftPointer<righPointer){
    while(numbers[leftPointer]<=pivot&&leftPointer<righPointer){
        leftPointer++;
    }
    while(numbers[righPointer]>=pivot&&leftPointer<righPointer){
        righPointer--;
    }
    swap(numbers,leftPointer, righPointer);
}
swap(numbers, leftPointer,heighIndex);
quickSort(numbers,lowIndex,leftPointer-1);
quickSort(numbers, leftPointer+1, heighIndex);

}
static void swap(int[]numbers,int index1,int index2){
int  temp=numbers[index1];
numbers[index1]=numbers[index2];
numbers[index2]=temp;
}
    

 }

Popularity 9/10 Helpfulness 2/10 Language java

Source: Grepper

Tags: java

Link to this answer
Share Copy Link

Contributed on Jun 03 2022

La Van Tho

0 Answers Avg Quality 2/10

avif to png

Comment

Google images trying to find the most random filetypes to use
https://i.kym-cdn.com/entries/icons/mobile/000/038/707/meme9.jpg

Popularity 10/10 Helpfulness 2/10 Language whatever

Source: Grepper

Tags: avif

Link to this answer
Share Copy Link

Contributed on Oct 06 2022

Teala24k

0 Answers Avg Quality 2/10

quick sort java

Comments(1)

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));
    }
}

Popularity 9/10 Helpfulness 2/10 Language java

Source: teamtreehouse.com

Tags: java

Link to this answer
Share Copy Link

Contributed on Nov 18 2022

Xanthous Xenomorph

0 Answers Avg Quality 2/10

Quick Sort Java Implementation

Contents

More Related Answers

Quick Sort Java Implementation

Closely Related Answers

avif to png

How to perform quick sort, in Java?

java quick sort

quicksort java

avif to png

java array quick sort

quicksort java

avif to png

quick sort java

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.