A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

本帖最后由 tacyjay在路上 于 2014-3-21 19:31 编辑
  1. /*
  2. 练习:有一个有序的数组,想要将一个元素插入到该数组中。
  3.           还要保证该数组是有序的。
  4. 本质:是如何获取该元素在数组中的位置。
  5. */

  6. class  ArrayTest
  7. {
  8.         public static void main(String[] args)
  9.         {
  10.                 int[] arr={2,4,5,7,19,32,45};
  11.                 int index1=getIndex(arr,3);//此处结果为index=0,按下面来说,应该是作为脚标为0的值插进去,后面顺延,但应该是作为脚标为1的值插进去吧??
  12.                 System.out.println("index1="+index1);        
  13.                 int index2=getIndex(arr,8);//视频里的例子,结果为index=4,作为脚标为4的值插进去,后面顺延。
  14.                 System.out.println("index2="+index2);        
  15.                 int index3=getIndex(arr,23);//结果为index=4,明明8与23插入的不是一个位置,为什么结果还是4??
  16.                 System.out.println("index3="+index3);        
  17.         }

  18.         public static int getIndex(int[]arr,int key)
  19.         {
  20.                 int min=0,max=arr.length-1,mid;
  21.                 while(min<max)
  22.                 {
  23.                         mid=(max+min)>>1;
  24.                         if(key>arr[mid])
  25.                                 min=mid+1;
  26.                         else if (key<arr[mid])
  27.                                 max=mid-1;
  28.                         else
  29.                                 return mid;
  30.                 }
  31.                 return min;//返回最小脚标min。  如果返回的是max,运行后是一样的结果!
  32.         }
  33. }
复制代码

今天在回顾毕老师day0407数组 折半查找中的练习时,自己换了几个数字进去,发现结果都不对,
代码和问题见上面,求大牛帮助。。。







评分

参与人数 1技术分 +2 收起 理由
黑妞~ + 2

查看全部评分

8 个回复

倒序浏览
  1. /*
  2. 练习:有一个有序的数组,想要将一个元素插入到该数组中。
  3.           还要保证该数组是有序的。
  4. 本质:是如何获取该元素在数组中的位置。
  5. */

  6. class  ArrayTest
  7. {
  8.         public static void main(String[] args)
  9.         {
  10.                 int[] arr={2,4,5,7,19,32,45};
  11.                 int index1=getIndex(arr,3);
  12.                 System.out.println("index1="+index1);        
  13.                 int index2=getIndex(arr,8);
  14.                 System.out.println("index2="+index2);        
  15.                 int index3=getIndex(arr,23);
  16.                 System.out.println("index3="+index3);        
  17.         }

  18.         public static int getIndex(int[]arr,int key)
  19.         {
  20.                 int min=0,max=arr.length-1,mid;
  21.                 while(min<=max)           //这里应该加一个=号!!!
  22.                 {
  23.                         mid=(max+min)>>1;
  24.                         if(key>arr[mid])
  25.                                 min=mid+1;
  26.                         else if (key<arr[mid])
  27.                                 max=mid-1;
  28.                         else
  29.                                 return mid;
  30.                 }
  31.                 return min;
  32.         }
  33. }
复制代码
错误之处已经指出 ,结果如下

评分

参与人数 1技术分 +1 收起 理由
菜小徐 + 1

查看全部评分

回复 使用道具 举报
Up↑Lee↗ 发表于 2014-3-21 15:57
错误之处已经指出 ,结果如下

汗。。。。
本来以为看的够仔细了,刚刚又重新找到视频,在对halfsearch第二种讲解时,毕老师还特地强调了为什么有=号。。。。。
等号 对查找问题几乎没有影响,但是对插入元素的问题影响可就不是一点两点了。。。{:3_65:}

没想到一个=号差了那么多,万分谢谢楼上的回答!!
回复 使用道具 举报
话说知道了位置以后,数组怎么插入元素?
回复 使用道具 举报
tacyjay在路上 发表于 2014-3-21 16:31
汗。。。。
本来以为看的够仔细了,刚刚又重新找到视频,在对halfsearch第二种讲解时,毕老师还特地强调 ...

哈哈   你也刚准备么
回复 使用道具 举报
  1. class Function00
  2. {
  3.         public static void main(String[] args)
  4.         {
  5.                 int [] array = new int []{1,2,3,4,5,6,7,8,9,0,11};
  6.                
  7.                
  8.                 //排序前的数组遍历
  9.                 print(array);
  10.                 smart();

  11.                 //数组中的最值
  12.                 int max;
  13.                 max=getMax(array);
  14.                 System.out.println("max="+max);
  15.                 smart();


  16.                 //排序
  17.                 //select(array);
  18.                 bubble(array);
  19.                 smart();

  20.                 //排序后
  21.                 print(array);
  22.                 smart();


  23.                 int key=6;
  24.                 int index=halfsearch(array,key);
  25.                 System.out.println("index="+index);


  26.        
  27.         }
  28.        
  29.         public static void smart()
  30.         {
  31.                 System.out.println("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
  32.         }
  33.        
  34.        
  35.        
  36.         //定义一个函数,实现数组遍历的功能
  37.         public static void print(int[] array)
  38.         {
  39.                 System.out.print("[");
  40.                 for (int x=0;x<=array.length-1;x++ )
  41.                 {
  42.                         if(x!=array.length-1)
  43.                                 System.out.print(array[x]+", ");
  44.                         else
  45.                                 System.out.println(array[x]+"]");
  46.                 }
  47.         }


  48.         //定义一个函数,实现获取数组中元素的最大值
  49.         /*
  50.         1.获取最值需要进行比较,每一次比较都会有一个较大的值,因为该值不确定,通过一个变量进行存储
  51.         2.让数组中的每一个元素都喝这个变量的值进行比较
  52.         3.当所有的元素都比较完成,那么该变量中存储的就是数组中的最大值了

  53.         步骤:
  54.         1.定义变量,初始化为数组中的任意一个元素即可
  55.         2.通过循环语句对数组进行遍历
  56.         3.在遍历过程中定义判断条件,如果遍历到的元素比变量中的元素大,就赋值给该变量

  57.         需要定义一个功能来完成,以提高复用性
  58.         1.明确结果,数组中的最大元素 int
  59.         2.未知内容,一个数组 int[]
  60.         */

  61.         //获取double类型数组的最大值,因为功能一致,所以定义相同函数名称,以重载形式存在
  62.         /*
  63.         public static double getMax(int[] array)
  64.         {
  65.        
  66.         }
  67.         */

  68.         //求最大值
  69.         public static int getMax(int[] array)
  70.         {
  71.                 int max=array[0];
  72.                 for (int x=1;x<array.length;x++)
  73.                 {                               
  74.                         if (max<array[x])
  75.                                 max=array[x];
  76.                 }
  77.                 return max;               
  78.         }



  79.         //选择排序
  80.         public static void select(int [] array)//void没有返回值
  81.         {
  82.                 for (int x=0;x<array.length-1;x++ )
  83.                 {
  84.                         for (int y=x+1;y<array.length;y++)
  85.                         {
  86.                                 if (array[x]>array[y])
  87.                                 {
  88.                                         /*
  89.                                         int temp;
  90.                                         temp=array[x];
  91.                                         array[x]=array[y];
  92.                                         array[y]=temp;
  93.                                         */
  94.                                         swap(array,x,y);

  95.                                 }
  96.                         }
  97.                 }
  98.         }
  99.        
  100.        
  101.         //冒泡排序
  102.         public static void bubble(int[]array)
  103.         {
  104.                 for (int x=0;x<array.length-1;x++ )
  105.                 {
  106.                         for (int y=0;y<array.length-x-1;y++ )//-x:让每一次比较的元素减少;-1:避免角标越界
  107.                         {
  108.                                 if(array[y]>array[y+1])
  109.                                 {       
  110.                                         /*
  111.                                         int temp;
  112.                                         temp=array[y];
  113.                                         array[y]=array[y+1];
  114.                                         array[y+1]=temp;
  115.                                         */
  116.                                         swap(array,y,y+1);
  117.                                 }

  118.                         }
  119.                 }
  120.         }


  121.         //位置置换功能的抽取封装
  122.         public static void swap(int [] array,int a,int b)
  123.         {
  124.                 array[a]=array[a]^array[b];
  125.                 array[b]=array[a]^array[b];
  126.                 array[a]=array[a]^array[b];
  127.         }

  128.         //希尔排序》》最快的排序方式



  129.         //折半查找
  130.         public static int halfsearch(int [] array,int key)
  131.         {
  132.                 int min,max,mid;
  133.                 min=0;
  134.                 max=array.length-1;
  135.                 mid=(max+min)/2;
  136.                 while (array[mid]!=key)
  137.                 {
  138.                         if (array[mid]<key)
  139.                                 min=mid+1;
  140.                         else if (array[mid]>key)
  141.                                 max=mid-1;

  142.                         if(min>max)
  143.                                 return -1;
  144.                         mid=(min+max)/2;
  145.                 }
  146.                 return mid;
  147.         }






  148. //ArrayIndexOutOfBoundsException: 3 :操作数组时,访问到了数组中不存在的角标

  149. //NullPointerException:空指针异常:当引用没有任何指向值为null的情况,该引用还在用于操作实体



  150. }
复制代码

你可以参考一下我这个,这是我当时看毕老师视频的时候写的,这是草稿,未曾整理,代码保证是正确的,希望对你有帮助

点评

恩恩。。谢谢。。已经知道了  发表于 2014-3-21 19:33
回复 使用道具 举报
Up↑Lee↗ 发表于 2014-3-21 18:49
哈哈   你也刚准备么

恩恩。。。速度太慢,得加紧时间了。。
加油哈。。
回复 使用道具 举报
马富林 发表于 2014-3-21 18:29
话说知道了位置以后,数组怎么插入元素?

这个不知道。。不好意思。
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马