퀵 재귀 및 비 - 재귀

빠른 정렬

• 피벗 요소 기준 소요
• 왼쪽 넣어 피봇보다 작은 요소, 피봇보다 오른쪽 큰 요소 넣어
• 생성하는 제 2 단계는 왼쪽과 같은 동작의 오른쪽 부분은 정렬이 완료 될 때까지

재귀

이해하기 쉬운 재귀, 주요 아이디어는 정렬이 재귀를 통해 신속하게 정렬 완료 될 때까지 약 2 서브 간격으로 계속하는 것입니다.

    public int[] quickSort(int[]arr){
        quickSort(arr,0, arr.length-1);
        return arr;
    }
    private int[] quickSort(int[]arr, int left, int right){
        if(left<right){
            int q = media(arr, left, right);
            quickSort(arr, left, q - 1);
            quickSort(arr, q + 1, right);
        }
        return arr;
    }
    private int media(int[]arr, int left, int right){
        int tmp = arr[right];
        int i = left;
        for(int j=left;j<right;j++){
            if(arr[j]<tmp){
                int x = arr[j];
                arr[j] = arr[i];
                arr[i] = x;
                i++;
            }
        }
        int x = arr[right];
        arr[right] = arr[i];
        arr[i] = x;
        return i;
    }

비 재귀

비 재귀의 단어에 대한 인위적으로 서브 인터벌을 저장하는 것이 필요하다. 재귀는 항상 푸시 프로세스 스택되어 있기 때문에 재귀 절차는 우선 우리가 스택을 사용하여 생각할 수있는, 비 재귀 프로그램으로 변경되었습니다.

    public int[] quickSort(int[]arr){
        Stack<Integer> stack = new Stack<>();
        int left = 0, right = arr.length - 1;
        stack.push(left);
        stack.push(right);
        while (!stack.isEmpty()){
            right = stack.pop();
            left = stack.pop();
            int tmp = arr[right];
            int i = left;
            for(int j=left;j<right;j++){
                if(arr[j]<tmp){
                    int x = arr[j];
                    arr[j] = arr[i];
                    arr[i] = x;
                    i++;
                }
            }
            int x = arr[right];
            arr[right] = arr[i];
            arr[i] = x;
            if(i-1>left) {
                stack.push(left);
                stack.push(i - 1);
            }
            if(i+1<right) {
                stack.push(i + 1);
                stack.push(right);
            }
        }
        return arr;
    }