Quick Sort wird nicht laufen C#

Question

Ich brauche meine QuickSort zum Sortieren von Dezimalzahlen nicht nur ganze Zahlen. Unten ist mein Code, wo die Datei gelesen wird, ich denke, das ist das Problem. Wie behebe ich das?

public static void Main() 
    { 
     quickSort q_Sort = new quickSort(); 

     string[] years = System.IO.File.ReadAllLines(@"C:\WS1_Rain.txt"); 
IEnumerable<int> yearArray = years.Select(item => int.Parse(item)); 
int[] array = yearArray.ToArray(); 

     q_Sort.array = array; 
     q_Sort.len = q_Sort.array.Length; 
     q_Sort.QuickSort(); 

     for (int j = 0; j < q_Sort.len; j++) 
     { 
      Console.WriteLine(q_Sort.array[j]); 
     } 
     Console.ReadKey(); 

Answer 1

int bedeutet eine ganze Zahl ganze Zahl keine Fraktionen

Answer 2

In C#, int speichert nur ganze Zahlen sind und doublefloat oder können beide ganze Zahlen speichern und Gleitkommazahlen.

Wenn Sie Ihr Programm in der Lage sein, beide Gleitkommazahlen und ganze Zahlen zu lesen, sollten Sie double verwenden oder sogar decimal, wenn Sie die Zahlen wollen genau sein, aber ich glaube nicht, dass es einen Bedarf dafür ist, . Ich werde double

verwenden Dies ist im Grunde, was Sie tun müssen,

• Änderung der Array in ein Array von Doppel
• Änderung der Variablen des sort Methode des Typs sein Doppel
• Verwenden Sie Convert.ToDouble anstelle von int.Parse

Versuchen Sie es!

---

Wenn Sie zu faul sind, hier ist der Code:

class quickSort 
{ 

    private double[] array = new double[1010]; 
    private int len; 

    public void QuickSort() 
    { 
     sort(0, len - 1); 
    } 

    public void sort(double left, double right) 
    { 
     double pivot; 
     double leftend, rightend; 

     leftend = left; 
     rightend = right; 
     pivot = array[left]; 

     while (left < right) 
     { 
      while ((array[right] >= pivot) && (left < right)) 
      { 
       right--; 
      } 

      if (left != right) 
      { 
       array[left] = array[right]; 
       left++; 
      } 

      while ((array[left] <= pivot) && (left < right)) 
      { 
       left++; 
      } 

      if (left != right) 
      { 
       array[right] = array[left]; 
       right--; 
      } 
     } 

     array[left] = pivot; 
     pivot = left; 
     left = leftend; 
     right = rightend; 

     if (left < pivot) 
     { 
      sort(left, pivot - 1); 
     } 

     if (right > pivot) 
     { 
      sort(pivot + 1, right); 
     } 
    } 

    public static void Main() 
    { 
     quickSort q_Sort = new quickSort(); 

     string[] years = System.IO.File.ReadAllLines(@"C:\WS1_Rain.txt"); 
     var yearArray = years.Select(item => Convert.ToDouble(item)); 
     double[] array = yearArray.ToArray(); 

     q_Sort.array = array; 
     q_Sort.len = q_Sort.array.Length; 
     q_Sort.QuickSort(); 

     for (int j = 0; j < q_Sort.len; j++) 
     { 
      Console.WriteLine(q_Sort.array[j]); 
     } 
     Console.ReadKey(); 
    } 
    } 
} 

Hinweis: Ich weiß nicht wirklich den schnellen Sortieralgorithmus.

Answer 3

Ich habe das nicht laufen, so dass es nicht ohne Zwicken funktionieren könnte, aber wenn es funktioniert Ich hoffe, Sie versuchen, herauszufinden, was mit Ihrer Version falsch war:

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 

namespace sortQuick 
{ 
    class quickSort 
    { 

     private double[] array = new double[1010]; 
     private int len; 

     public void QuickSort() 
     { 
      sort(0, len - 1); 
     } 

     public void sort(int left, int right) 
     { 
      int leftend, rightend; 
      double pivot; 

      leftend = left; 
      rightend = right; 
      pivot = array[left]; 

      while (left < right) 
      { 
       while ((array[right] >= pivot) && (left < right)) 
       { 
        right--; 
       } 

       if (left != right) 
       { 
        array[left] = array[right]; 
        left++; 
       } 

       while ((array[left] <= pivot) && (left < right)) 
       { 
        left++; 
       } 

       if (left != right) 
       { 
        array[right] = array[left]; 
        right--; 
       } 
      } 

      left = leftend; 
      right = rightend; 

      if (left < pivot) 
      { 
       sort(left, pivot - 1); 
      } 

      if (right > pivot) 
      { 
       sort(pivot + 1, right); 
      } 
     } 

     public static void Main() 
     { 
      quickSort q_Sort = new quickSort(); 

      double[] years = System.IO.File.ReadAllLines(@"C:\WS1_Rain.txt"); 
      IEnumerable<double> yearArray = years.Select(item => double.Parse(item)); 
      double[] array = yearArray.ToArray(); 

      q_Sort.array = array; 
      q_Sort.len = q_Sort.array.Length; 
      q_Sort.QuickSort(); 

      for (int j = 0; j < q_Sort.len; j++) 
      { 
       Console.WriteLine(q_Sort.array[j]); 
      } 
      Console.ReadKey(); 
     } 
    } 
} 

UPDATE: Ok , Ihr Code war schwer zu modifyso Ich habe den Originalcode von here und modifiziert, um mit Doppel zu arbeiten. Also hier ist eine funktionierende Version (ich habe es getestet).

class Program 
    { 
     static public int Partition(double[] numbers, int left, int right) 
     { 
      double pivot = numbers[left]; 
      while (true) 
      { 
       while (numbers[left] < pivot) 
        left++; 

       while (numbers[right] > pivot) 
        right--; 

       if (left < right) 
       { 
        double temp = numbers[right]; 
        numbers[right] = numbers[left]; 
        numbers[left] = temp; 
       } 
       else 
       { 
        return right; 
       } 
      } 
     } 

     static public void QuickSort_Recursive(double[] arr, int left, int right) 
     { 
      // For Recusrion 
      if (left < right) 
      { 
       int pivot = Partition(arr, left, right); 

       if (pivot > 1) 
        QuickSort_Recursive(arr, left, pivot - 1); 

       if (pivot + 1 < right) 
        QuickSort_Recursive(arr, pivot + 1, right); 
      } 
     } 

     static void Main(string[] args) 
     { 
      double[] numbers = System.IO.File.ReadAllLines(@"C:\WS1_Rain.txt").Select(p => double.Parse(p)).ToArray(); 
      int len = 9; 

      Console.WriteLine("QuickSort By Recursive Method"); 
      QuickSort_Recursive(numbers, 0, len - 1); 
      for (int i = 0; i < 9; i++) 
       Console.WriteLine(numbers[i]); 

      Console.WriteLine(); 
      Console.ReadKey(); 
     }