算法复杂度课后作业

算法复杂度课后作业

要求：

用 Java语言实现下列算法并进行单元测试， 请给出算法的时间复杂度。

（1）求一个整数二维数组Arr[N][N]的所有元素之和。

（2）对于输入的任意 3 个整数， 将它们按从小到大的顺序输出。

（3）对于输入的任意 n 个整数， 输出其中的最大和最小元素。

解答：

(1)要用到两个循环来做，第一个循环是列的，第二个循环是该列的第几个下标，然后将其累加，最后返回结果。用到两个循环，而且循环中的变量的增长为1。因此，第一个问题的时间复杂度是： O(n^2)

(2)第二个只是排序，我用的是快速排序法来实现排序，按照正常情况，快速排序的时间复杂度为：O(n logn)，但是只输入3个数，递归一次就结束了，所以时间复杂度为: O(1)

(3)第三个直接可以用上第二问的排序先将数组顺序排好，然后将第一个和最后一个调出来就可以了。由于调出的时候时间复杂度都是O(1),因此第三问的时间复杂度和第二问的时间复杂度一样，是： O(n logn)

实现代码: Task.java

/**
 * Created by Funny_One on 2017/9/23.
 */
public class Task {
    //求二元数组的和
   public int total(int[][] Arr) {
       int total = 0;
       for (int index = 0; index < Arr.length; index++) {
           for (int viceIndex = 0; viceIndex < Arr[0].length; viceIndex++) {
               total += Arr[index][viceIndex];
           }
       }
       return total;
   }

   //对数组进行排序
    public void quickSort(int[]data,int min,int max){
        int pivot;
        if(min<max){
            pivot = partion(data,min,max);
            quickSort(data,min,pivot-1);
            quickSort(data,pivot+1,max);
        }
        for(int index=0;index<data.length;index++){
            System.out.println("  "+data[index]+"  ");
        }
       System.out.println();
    }
    private static int partion(int[] data,int min,int max){
        int partitionValue = data[min];
        int left = min ;
        int right = max;

        while (left<right){
            while (data[left] <= partitionValue && left<right){
                left++;
            }

            while (data[right] > partitionValue){
                right--;
            }

            if(left < right){
                swap(data,left,right);
            }

        }
        swap(data,min,right);
        return right;
    }

    private static void swap(int[] data, int index1, int index2){
        int temp = data[index1];
        data[index1]= data[index2];
        data[index2]= temp;
    }
    
    public boolean judge(int[] data){
        boolean judge=false;
        for(int index=0;index<data.length-1;index++){
            if(data[index+1]>data[index]){
                judge = true;
            }
        }
        return judge;
    }

    //获得数组的最大值和最小值
    public String Select(int[] arr){
        quickSort(arr,0,arr.length-1);
        return "Min Num in the array:"+arr[0]+" Max Num in the array:"+arr[arr.length-1];
    }
  

}

测试用例：TaskTest.java

import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

/**
 * Created by Funny_One on 2017/9/23.
 */
public class TaskTest extends TestCase {
    private static final String TEST_FAILURE_MSG = "test fail";
    public static Test suite(){
        TestSuite suite=new TestSuite("Task测试程序");
        suite.addTestSuite(TaskTest.class);
        return  suite;
    }
    Task t = new Task();
    public void testTotal() throws Exception {
        int[][] Arr = {{1,2,3}};
        assertEquals(errorMsgTitle("The total is 6"),6,t.total(Arr));

    }

    public void testQuickSort() throws Exception {
        int[]data = {1,5,9,3,7};
        t.quickSort(data,0,4);
        assertEquals(errorMsgTitle("get true"),true,t.judge(data));
    }

    public void testSelect() throws Exception {
        int[] arr = {5,6,9,10,3,2,8,7};
        assertEquals(errorMsgTitle("get the min and max"),"Min Num in the array:"+2+" Max Num in the array:"+10,t.Select(arr));
    }

    private String errorMsgTitle(String msg){
        return msg+" "+ TEST_FAILURE_MSG;
    }
}

测试效果：