تمرین مرتب سازی سریع

۱۰
۱۰۰ ۱۴ ۱۰ ۵ ۲ ۷ ۴ ۹ ۵ ۸

۲ ۴ ۵ ۵ ۷ ۸ ۹ ۱۰ ۱۴ ۱۰۰

import java.io.*;

public class File
{
    private String input_path;
    private String output_path;

    public File()
    {
        this.input_path = "d://input.txt";
        this.output_path = "d://output.txt";
    }
    public String[] read() throws IOException
    {
        FileInputStream input = null;
        String[] data=null;
        int i=0;
        try{
            input = new FileInputStream(input_path);
            DataInputStream dataInputStream = new DataInputStream(input);
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(dataInputStream));
            String strLine;
            while ((strLine=bufferedReader.readLine()) != null)
            {
                if(data==null)
                {
                    data = new String[1];
                    continue;
                }
                else if(i==1)
                {
                    break;
                }
                data[i] = strLine + (char) 13 + (char) 10;
                i += 1;
            }
        }
        finally
        {
            if(input == null)
            {
                input.close();
            }
        }
        return data;
    }
    public void write(String data, boolean append) throws IOException
    {
        BufferedWriter output = null;
        try
        {
            output = new BufferedWriter(new FileWriter(output_path, append));
            if(data==null)
                output.write("");
            else
                output.write(data + " ");
            output.close();
        }
        finally
        {
            if(output == null)
            {
                output.close();
            }
        }
    }
}

public class QuickSort
{
    private int counter;
    private int array_bound;
    private int[] array;
    private int partition(int arr[], int low, int high)
    {
        int left = low + 1;
        int right = high;
        int temp;
        int pivot = arr[low];

        while(left <= right)
        {
            while(arr[left] <= pivot && left <= right)
                left++;
            while(arr[right] > pivot && left <= right)
                right--;
            if(left < right)
            {
                if(left>=counter || right>=counter)
                    continue;
                temp = arr[left];
                arr[left] = arr[right];
                arr[right] = temp;
            }
        }
        arr[low] = arr[right];
        arr[right] = pivot;
        return right;
    }

    QuickSort()
    {
        counter = 0;
        array_bound = 100000;
        array = new int[array_bound];
    }
    public void setArray(int value)
    {
        if(counter>100000)
            return;
        array[counter] = value;
        counter+=1;
    }
    public void sort(int low ,int high)
    {
        if (low < high)
        {
            int pivot = partition(array, low, high);
            sort(low, pivot - 1);
            sort(pivot + 1, high);
        }
    }
    public int[] result()
    {
        return array;
    }
    public int getCounter()
    {
        return counter;
    }
}

import java.io.*;

public class Main
{
    public static void main(String[] args) throws IOException
    {
        File file = new File();
        file.write(null, false);
        QuickSort quicksort = new QuickSort();
        String[] construction = file.read();
        String job="";
        int[] result;

        for(String my_construction:construction)
        {
            for (int i=0; i<my_construction.length(); i++)
            {
                if(!Character.isWhitespace(my_construction.charAt(i)))
                {
                    job += String.valueOf(my_construction.charAt(i));
                }
                else
                {
                    if(!job.equals(""))
                        quicksort.setArray(Integer.valueOf(job));
                    job="";
                }
            }
        }
        quicksort.sort(0, quicksort.getCounter()-1);
        result = quicksort.result();
        int i=0;
        for (int my_result:result)
        {
            if(i>=quicksort.getCounter())
                break;
            System.out.println(my_result);
            file.write(String.valueOf(my_result),true);
            i+=1;
        }
    }
}