算法——快速排序迭代式和递归式的Java实现

快速排序迭代式和递归式的Java实现

　　快速排序基于分治法的思想，在待排序表中任选一值作为中枢值 pivot，一趟快排将所有大于该值的元素置于一边，小于该值的元素置于另一边，这样一个元素在排序中的最终位置就已确定。接下来将中枢值左右两边的区域分别进行下一趟快排，直到所有的元素都有序排列。

　　空间效率：最好情况为 O(log2(n+1))，最坏情况为 O(n)，平均空间复杂度 O(log2(n))。

　　时间效率：最好情况为 O(n*log2(n))，最坏情况 O(n^2)，平均时间复杂度 O(n*log2(n))。

　　快速排序是所有内部排序中平均性能最优的算法，同时也是一个不稳定的排序算法。

 

递归式

public class Test {
    
    public static void main(String[] args) {
        
        int[] nums = {2, 12, 32, 32, 43, 5, 74, 13, 87, 12, 44, 2, 41, 5, 33};
        
        recursiveQuicksort(nums,0,nums.length-1);
        
        System.out.println("Sorted array : " + Arrays.toString(nums));
        
    }
    
    //recursiveQuicksort(int[] 被排序数组, int 数组下界, int 数组上界)
    private static void recursiveQuicksort(int[] nums, int low, int high) {
        
        if(low < high){
            
            int pivotpos = partition(nums, low, high);
            
            recursiveQuicksort(nums, low, pivotpos -1);
            recursiveQuicksort(nums, pivotpos + 1, high);
            
        }
    }

    private static int partition(int[] nums, int low, int high) {
        
        //将当前列表中第一个元素设为中枢值
        int pivot = nums[low];  
        
        while(low < high){
            
            //找到第一个小于中枢值的数，置于low的位置
            while(low < high && nums[high] >= pivot){
                --high;
            }
            nums[low] = nums[high];

            //找到第一个大于中枢值的数，置于high的位置
            while(low < high && nums[low] <= pivot){
                ++low;
            }
            nums[high] = nums[low];
        }
        
        //这样一趟下来nums[low]左端都是小于中枢值的数，右端都是大于中枢值的数，一个元素的最终排序位置确定
        nums[low] = pivot;
        
        return low;
    }
}

 

迭代式

　　递归的操作更加便于理解，但是递归频繁的调用函数会不断让参数和其它额外的变量入栈，从而造成栈空间的极大浪费，如果调用层次很深，还有可能造成栈溢出，而入栈也会有性能损失。因此迭代式自己模拟入栈的过程从而提高快排的效率。

public class Test {
    
    public static void main(String[] args) {
        
        int[] nums = {34, 32, 43, 12, 11, 32, 22, 21, 32};

        System.out.println("Unsorted array : " + Arrays.toString(nums));

        iterativeQuicksort(nums);

        System.out.println("Sorted array : " + Arrays.toString(nums));

    }

    public static void iterativeQuicksort(int[] nums) {
        
        //新建栈，模拟递归操作
        Stack stack = new Stack();
        
        stack.push(0);
        stack.push(nums.length);

        while (!stack.isEmpty()) {
            int high = (int)stack.pop();
            int low = (int)stack.pop();

            if (high - low < 2) {
                continue;
            }
            
            //pivot为low与high的平均值，保证随机性，降低抽到数组中最小值或最大值的概率
            int p = low + ((high - low) / 2); //pivot为low与high的平均值，这样写防止溢出

            //经过一趟partition后，p所在的位置已是排序后的最终位置
            p = partition(nums, p, low, high);

            stack.push(p + 1);
            stack.push(high);

            stack.push(low);
            stack.push(p);
        }
    }

    private static int partition(int[] input, int position, int start, int end) {
        
        int l = start;
        int h = end - 2;
        
        int pivot = input[position];

        //将pivot换至最右端
        swap(input, position, end - 1); 

        //筛选pivot的最终位置
        while (l < h) {
            if (input[l] < pivot) {
                l++;
            } else if (input[h] >= pivot) {
                h--;
            } else {
                swap(input, l, h);
            }
        }
        //pos为pivot的最终位置
        int pos = h;
        
        //如果pivot左边的数都小于它，说明它本来就应该在最右端的位置，因此pos++
        if (input[h] < pivot) {
            pos++;
        }
        swap(input, end - 1, pos);
        
        return pos;
    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

 

递归与迭代

递归：重复调用函数自身实现循环

• 优点：

  • 极大的减少了代码量，代码简单易读

  • 将大问题转化成小问题，逻辑清晰

• 缺点：

  • 递归不断调用函数，不断压栈，浪费空间容易造成栈溢出

  • 频繁的入栈出栈操作也会导致性能损失

 

迭代：函数内某段代码实现循环，不断把变量的原值推导成新值，直到最终结果产生

• 优点：

  • 效率比递归高，运行时间只随循环的增加而增加

  • 不需要反复调用从而占用栈的空间

• 缺点：

  • 代码复杂，较难理解

  • 面对复杂问题时，难以构思代码