黑马程序员技术交流社区

标题: 整了半天啊，各位大神来看看，有木有可以简化的地方 [打印本页]
作者: 朱志江    时间: 2013-3-16 16:31
标题: 整了半天啊，各位大神来看看，有木有可以简化的地方
/*
需求：给定一个数组{1,2,3,4,5,6,7,8,9}。获取数组中最大值和最小值

思想：1、获取最大值要进行比较，每一次比较都会获取一个最大值，该值不确定，定义一个变量进行存储。
          2、让数组中每一个元素和这个变量进行比较，如果大于该变量的值，就记录比较后的较大值。

步骤：1、定义一个变量，用数组中任意一个值做初始化值.明确结果，最大值是int类型
          2、通过循环语句对数组进行遍历,未知的内容，用数组 int[]
          3、在变量过程中定义判断条件，如果遍历到的元素比变量中的大，就赋值给该变量。
*/
class Shuzubj
{
public static void main(String[] args)
        {
                int[] arr={1,2,3,4,5,6,7,8,9};
                int big = getmax(arr);
                int sma = getmin(arr);
                System.out.println("big="+big);
                System.out.println("sma="+sma);
        }

        public static int getmax(int[] arr)
        {
                int big = 0;

                for (int x =1;x<arr.length ;x++ )
                {
                        if(arr[x]>arr[big])
                                big =x;
                }
                return arr[big];
        }
        public static int getmin(int[] arr)
        {
                int sma = 0;

                for (int x =1;x<arr.length ;x++ )
                {
                        if(arr[x]<arr[sma])
                                sma =x;
                }
                return arr[sma];
        }




} 我想的就是在提高复用性的前提先 能不能简化
作者: 何仕映    时间: 2013-3-16 16:42
本帖最后由 何仕映 于 2013-3-16 16:47 编辑

可以，你可以把获取最大值和最小值、打印输出等方法都封装在一个工具类中，当然这些方法都用静态修饰，以便直接可以通过类名去调用。这样，你不仅在这个程序中能使用，在其他的程序你也可以直接调用。
下面这个是课堂上的一个实例，你可以看一下。

  2. public class ArrayTool
  3. {

  5. //空参数构造函数。
  6. private ArrayTool(){} //将构造函数私有化，以防止建立对象

  8. //获取一个整形数组中的最大值。
  9. public static int getMax(int[] arr)
  10. {
  11. int max = 0;
  12. for(int x=1; x<arr.length; x++)
  13. {
  14. if(arr[x]>arr[max])
  15. max = x;
  16. }
  17. return arr[max];
  18. }

  20. //获取一个整形数组中的最小值。
  21. public static int getMin(int[] arr)
  22. {
  23. int min = 0;
  24. for(int x=1; x<arr.length; x++)
  25. {
  26. if(arr[x]<arr[min])
  27. min = x;
  28. }
  29. return arr[min];
  30. }

  32. //给int数组进行选择排序。
  33. public static void selectSort(int[] arr)
  34. {
  35. for (int x=0; x<arr.length-1 ; x++ )
  36. {
  37. for(int y=x+1; y<arr.length; y++)
  38. {
  39. if(arr[x]>arr[y])
  40. {
  41. swap(arr,x,y);
  42. }
  43. }
  44. }
  45. }

  47. //给int数组进行冒泡排序。
  48. public static void bubbleSort(int[] arr)
  49. {
  50. for (int x=0; x<arr.length-1 ; x++ )
  51. {
  52. for(int y=0; y<arr.length-x-1; y++)
  53. {
  54. if(arr[y]>arr[y+1])
  55. {
  56. swap(arr,y,y+1);
  57. }
  58. }
  59. }
  60. }

  62. //给数组中元素进行位置的置换。
  63. private static void swap(int[] arr,int a,int b)
  64. {
  65. int temp = arr[a];
  66. arr[a] = arr[b];
  67. arr[b] = temp;
  68. }

  70. //用于打印数组中的元素。打印形式是
  71. public static void printArray(int[] arr)
  72. {
  73. System.out.print("[");
  74. for(int x=0; x<arr.length; x++)
  75. {
  76. if(x!=arr.length-1)
  77. System.out.print(arr[x]+", ");
  78. else
  79. System.out.println(arr[x]+"]");
  80. }
  81. }
  82. }
复制代码
作者: HM张超    时间: 2013-3-16 16:42
最简单的用冒泡排序！升序降序我随你了！
取第一个最后一个就OK了！
作者: itserious    时间: 2013-3-16 16:57
这是最简单的方法：
class Shuzubj
{
public static void main(String[] args)
       {
                Integer[] arr={1,2,3,4,5,6,7,8,9};
               
              List<Integer> list= Arrays.asList(arr);
               
            int max=Collections.max(list);
            int min=Collections.min(list);
             System.out.println("max="+max);
             System.out.println("min="+min);              
        }

}
作者: 张文星    时间: 2013-3-16 17:14
没有简化的方法，无论你用jdk提供的函数还是你上面自己写的函数，这已经是求最大值的时间复杂度最低的了，除非本来数组就是有序的，不然只有一个一个的比较。
作者: 徐鸿燕    时间: 2013-3-16 17:17
  1. /*
  2. * 打印最大值和最小值。
  3. * 由于你提供的数组里的元素已经排序好。
  4. * 为了使getNum()表现的更明显，就第一位前和最后一位后分别加了一个数字。
  5. * 步骤：可以将数组中的元素以升序排序。
  6. * 获取最大值：为排序后数组中的最后一个元素。
  7. * 获取最小值：为排序后数组中的第一个元素。
  8. */
  9. public class Shuzubj{
  10.         public static void main(String[] args) {
  11.                 Demo d = new Demo();
  12.                 int[] arr={432, 1, 2, 3, 4, 5, 6, 7, 8, 9 ,0};
  13.                 d.selectSort(arr);//排序后
  14.                 System.out.println("big = " + arr[arr.length -1]);//最大值是数组中最后一个元素。
  15.                 System.out.println("sma = "+ arr[0]);//最小值是数组中第一个元素。
  16.         }
  17. }
  18. class Demo{//工具类
  19.         public static void selectSort(int[] arr){//选择排序：升序。
  20.                 for (int i = 0; i < arr.length - 1; i++){
  21.                         for (int j = i + 1; j < arr.length; j++){
  22.                                 if (arr[i] > arr[j]){//如果第一个元素比第二个元素小。就置换位置。
  23.                                 int temp = arr[i];
  24.                                 arr[i] = arr[j];
  25.                                 arr[j] = temp;
  26.                                 }
  27.                         }
  28.                 }
  29.         }
  30. }
复制代码
作者: itserious    时间: 2013-3-16 17:26
//用一个boolean值来判断你是取最大值，还是最小值。
class Shuzubj {
        public static void main(String[] args) {
                int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
                int big = getMaxMin(arr, true);
                int sma = getMaxMin(arr, false);
                System.out.println("big=" + big);
                System.out.println("sma=" + sma);
        }

        public static int getMaxMin(int[]arr, boolean flag) {//用一个boolean值来判断你是取最大值，还是最小值。
                int num = 0;
                for (int x = 1; x < arr.length; x++) {
                        if (flag) {
                                if (arr[num] < arr[x]) {

                                }
                        } else {
                                if (arr[num] > arr[x]) {
                                }
                                num = x;
                        }
                }
                return arr[num];
        }
}
作者: 郝强勇    时间: 2013-3-16 18:23
     用Arrays工具类的sort方法先把数组排序，之后获得一头一尾不就是最小值和最大值了吗，但也许这不是楼主想要的，不管怎么样，班门弄斧一下下。
     public static void main(String[] args) {
                int[] arr = {8,0,9,5,2,9,12,4};
                Arrays.sort(arr);
                int max = arr[arr.length-1];
                int min = arr[0];
                System.out.println(max+"------"+min);
        }
作者: 崔自成    时间: 2013-3-16 20:14
如果数组里的元素是无序的，就先把数组排序然后就能很容易的找出，最大和最小值
最快的是有 java.util包下的 Arrays类的 排序方法
或者用毕老师视频里的冒泡排序
  1. public class Test2 {

  3.         public static void main(String[] args) {
  4.                 //定义数组，并初始化
  5.                 int[] a = { 7, 6, 20, 1, 5, 40, 33, 6, 7 };
  6.                 //定义中间变量，方便调换数组中元素的位置
  7.                 int temp = 0;
  8.                 //数组长度
  9.                 int len = a.length;
  10.                 //遍历数组
  11.                 for (int i = 0; i < a.length-1; i++) {
  12.                        
  13.                         for (int j = 0; j < a.length-1 - i; j++) {
  14.                                 //比较相邻两个元素，值较大的往后移位
  15.                                 if (a[j] > a[j + 1]) {
  16.                                         temp = a[j];
  17.                                         a[j] = a[j + 1];
  18.                                         a[j + 1] = temp;
  19.                                 }
  20.                         }
  21.                 }
  22.                
  23.                
  24.                 //最大值
  25.                 System.out.println(a[0]);

  27.                 //最小值
  28.                 System.out.println(a[len-1]);
  29.                
  30.         }
  31. }
复制代码




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2