“Java Schnelle Sorte” Code-Antworten

Java Schnelle Sorte

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

Schnelle Sortier -Java -Implementierung

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

Quicksort Java

//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());
  }
}
Yellowed Yacare

Java Array schnell 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;
    }
}
Homeless Hummingbird

Ähnliche Antworten wie “Java Schnelle Sorte”

Fragen ähnlich wie “Java Schnelle Sorte”

Weitere verwandte Antworten zu “Java Schnelle Sorte” auf Java

Durchsuchen Sie beliebte Code-Antworten nach Sprache

Durchsuchen Sie andere Codesprachen