cs61b homework8

part1 实现mergesort，很奇怪的是感觉按作业上的步骤并没有用到recursion，因为用到了makeQueueOfQueues这个函数，不过不用这个函数用recursion也是可以直接做的。

代码：

makeQueueOfQueues：

public static LinkedQueue makeQueueOfQueues(LinkedQueue q) {
          if(q.isEmpty())
              return null;
       try{
           LinkedQueue q1=new LinkedQueue();
           while(!q.isEmpty()){
               LinkedQueue template=new LinkedQueue();
               template.enqueue(q.dequeue());
               q1.enqueue(template);
           }
           return q1;
       }catch(QueueEmptyException e){
           e.printStackTrace();
           return null;
       }
       
      }

mergeSortedQueues：

 public static LinkedQueue mergeSortedQueues(LinkedQueue q1, LinkedQueue q2)  {
        LinkedQueue q=new LinkedQueue();
        try{
        while(!q1.isEmpty()&&!q2.isEmpty()){
            Comparable comp1=(Comparable)q1.front();
            Comparable comp2=(Comparable)q2.front();
            if(comp1.compareTo(comp2)<0)
                q.enqueue(q1.dequeue());
            else if(comp1.compareTo(comp2)>0)
                q.enqueue(q2.dequeue());
            else if(comp1.compareTo(comp2)==0){
                q.enqueue(q1.dequeue());
                q.enqueue(q2.dequeue());
            }
        }
        if(!q1.isEmpty())
            q.append(q1);
        else if(!q2.isEmpty())
            q.append(q2);
        return q;
        }catch(QueueEmptyException e){
            e.printStackTrace();
            return q;
        }
      }

mergesort：

public static void mergeSort(LinkedQueue q) {
          try{
        LinkedQueue queue=makeQueueOfQueues(q);
        while(queue.size()!=1){
            queue.enqueue(mergeSortedQueues((LinkedQueue) queue.dequeue(),(LinkedQueue) queue.dequeue()));
        }
        LinkedQueue q1=(LinkedQueue) queue.dequeue();
        while(!q1.isEmpty())
            q.enqueue(q1.dequeue());
       
        }
          catch(QueueEmptyException e){
              e.printStackTrace();
          }
      }

part2：实现quicksort，partition后不断recurse qSmall和qLarge

partition：

public static void partition(LinkedQueue qIn, Comparable pivot, 
                                   LinkedQueue qSmall, LinkedQueue qEquals, 
                                   LinkedQueue qLarge) {
        try{
            if(qIn.size()<2)
                return;
        int n=qIn.size();
        Random rand=new Random();
        int r=rand.nextInt(n);
        pivot=(Comparable)qIn.nth(r);
        while(!qIn.isEmpty()){
            Comparable front=(Comparable)qIn.front();
            if(front.compareTo(pivot)<0)
                qSmall.enqueue(qIn.dequeue());
            else if(front.compareTo(pivot)>0)
                qLarge.enqueue(qIn.dequeue());
            else if(front.compareTo(pivot)==0)
                qEquals.enqueue(qIn.dequeue());
        }
        }catch(QueueEmptyException e){
            e.printStackTrace();
        }
      }

quickSort：

 public static void quickSort(LinkedQueue q) {
        if(q.size()<2)
            return;
        LinkedQueue qSmall=new LinkedQueue();
        LinkedQueue qLarge=new LinkedQueue();
        LinkedQueue qEquals=new LinkedQueue();
        Comparable pivot=null;
        partition(q,pivot,qSmall,qEquals,qLarge);
        quickSort(qSmall);
        quickSort(qLarge);
        q.append(qSmall);
        q.append(qEquals);
        q.append(qLarge);
      }

运行结果：

Queue: [ 2 0 6 3 1 7 7 9 9 5 ]
After merge sort: [ 0 1 2 3 5 6 7 7 9 9 ]
Queue
[ 8 0 9 3 9 8 3 0 1 9 ]
After quick sort[ 0 0 1 3 3 8 8 9 9 9 ]
Mergesort time, 1000000 Integers:  2971 msec.
Quicksort time, 1000000 Integers:  2049 msec.

part3：

time为1000000如上

time为100000时，

Mergesort time, 100000 Integers: 207 msec.
Quicksort time, 100000 Integers: 133 msec.

time为10000：

Mergesort time, 10000 Integers: 12 msec.
Quicksort time, 10000 Integers: 11 msec.

time为1000：

Mergesort time, 1000 Integers: 4 msec.
Quicksort time, 1000 Integers: 2 msec.

time为100：

Mergesort time, 100 Integers: 1 msec.
Quicksort time, 100 Integers: 1 msec.

感觉Quicksort还是要快一些