算法题——快速排序

2024年1月30日 212次阅读

给出一个区间的集合, 请合并所有重叠的区间。

示例：
给出 [1,3],[2,6],[8,10],[15,18],
返回 [1,6],[8,10],[15,18].

已知：
    static class Interval {
        int start;
        int end;
        Interval() { start = 0; end = 0; }
        Interval(int s, int e) { start = s; end = e; }
        @Override
        public String toString() {
            // TODO Auto-generated method stub
            return start+"";
        }
    }

求：
    public static ArrayList<Interval> quicksort(ArrayList<Interval> list){
        // 开始你的表演
    }

使用java封装的sort（）方法解答：

public static List<Interval> merge(List<Interval> intervals) {
        if(intervals.size()<2){
            return intervals;
        }
        List<Interval> mList=new ArrayList();
        intervals.sort(new Comparator<Interval>() {

            @Override
            public int compare(Interval arg0, Interval arg1) {
                // TODO Auto-generated method stub
                System.out.println("arg0="+arg0.start+",arg1="+arg1.start);
                return arg0.start-arg1.start;
            }

        });
        Interval l1=intervals.get(0);
        mList.add(l1);
        for(int i=1; i<intervals.size(); i++){
            Interval l2=intervals.get(i);
            if(l1.end>=l2.start){
                l1.end=Math.max(l1.end, l2.end);
                mList.set(mList.size()-1, l1);
            }else{
                mList.add(l2);
                l1=l2;
            }
        }
        return mList;

    }

继续看：
其实这是一道快速排序算法，如果不用sort方法，我们可以自己写出来。

    public static ArrayList<Interval> quicksort(ArrayList<Interval> list){
        if(list.size()<2){
            return list;
        }
        Interval pivot=list.get(0);
        ArrayList<Interval> mList=new ArrayList<>();
        ArrayList<Interval> less=new ArrayList<>();
        ArrayList<Interval> greater=new ArrayList<>();
        for(int i=1; i<list.size(); i++){
            if(list.get(i).start>pivot.start){
                greater.add(list.get(i));
            }else {
                less.add(list.get(i));
            }

        }
        mList.addAll(quicksort(less));
        mList.add(pivot);
        mList.addAll(quicksort(greater));
        return mList;
    }

快速排序内部使用递归，只需要执行三步，即可：

  1. 选择基准值
  2. 将数组分成领个子数组，小于基准值的数组放到基准值左边，大于基准值的数组放到基准值右边
  3. 重复前面两步，对这两个自数据进行快速排序

在平均情况下，快速排序的运行时间为O(nlog(n));在最糟糕情况，这种算法的运行时间为O(n^2).

点赞