JAVA基础笔试题（二）--直接排序，冒泡排序，二分查找

直接排序

需求：定义一个函数接收一个int类型的数组对象,把数组中的最大值放在数组中的第一位。

选择排序(直接排序)：使用一个元素与其他的元素挨个比较一次，符合条件交换位置。

class Demo9{ 

         publicstatic void main(String[] args)

         {

                  int[]arr = {12,5,17,8,9};  //对于5元素的数组，只需要找出4个最大值就可以排序了。

                  selectSort(arr);

         }

         publicstatic void selectSort(int[] arr){ 

                  //把最大值放在首位置。

                  for(inti =1 ; i<arr.length ; i++){ //找出最大值

                                   if(arr[i]>arr[j]){

                                            //交换位置

                                            inttemp = arr[i];

                                            arr[i]= arr[0];

                                            arr[0]= temp;

                                   }

                  }

                  //把老二放在第二个位置

                  for(inti = 2  ; i< arr.length ; i++){

                          if(arr[i]>arr[1]){

                                   inttemp = arr[i];

                                   arr[i]= arr[1];

                                   arr[1]= temp;

                          }

                  }

                  //把老三放在第三个位置

                  for(inti = 3  ; i< arr.length ; i++){

                          if(arr[i]>arr[2]){

                                   inttemp = arr[i];

                                   arr[i]= arr[2];

                                   arr[2]= temp;

                          }

                  }

                  //把老四放在第四个位置

                  for(inti = 4  ; i< arr.length ; i++){

                          if(arr[i]>arr[3]){

                                   inttemp = arr[i];

                                   arr[i]= arr[3];

                                   arr[3]= temp;

                          }

                  }

                  //遍历数组，查看效果

                  System.out.print("目前的元素：");

                  for(int i = 0 ; i<arr.length  ;i++){

                          System.out.print(arr[i]+",");

                  }

         }

}

采用双重循环的方式进行排序：

for(int j = 0; j<arr.length-1;j++){  // 控制的是轮数。

         for(inti = j+1 ; i<arr.length ; i++){ //找出最大值

                  if(arr[i]>arr[j]){

                          //交换位置

                          inttemp = arr[i];

                          arr[i]= arr[j];

                          arr[j]= temp;

                  }

         }

}

冒泡排序

需求：定义一个函数接收一个int类型的数组对象,把数组中的最大值放在数组中的最后一位。

冒泡排序：冒泡排序的思想就是使用相邻的两个元素挨个比较一次，符合条件交换位置。

class Demo10

{

         publicstatic void main(String[] args)

         {

                  int[]arr = {12,8,17,5,9}; //最大的索引值: 4   容量：5

                bubbleSort(arr);

         }

         publicstatic void bubbleSort(int[] arr){

                  //把最大值放在最后一个位置

                  for(inti = 0 ; i<arr.length-1 ; i++){  //找出一个最大值 

                                   //相邻的元素比较

                                   if(arr[i]>arr[i+1]){

                                            inttemp = arr[i];

                                            arr[i]= arr[i+1];

                                            arr[i+1]= temp;

                                   }

                          }

                  }

                  //把老二放在倒数第二个位置上。

                  for(inti = 0 ;  i <arr.length-1-1 ; i++){

                          if(arr[i]>arr[i+1]){

                                   inttemp = arr[i];

                                   arr[i]= arr[i+1];

                                   arr[i+1]= temp;

                          }      

                  }

                  //把老三放在倒数第三个位置上。

                  for(inti = 0 ;  i <arr.length-1-2 ; i++){

                          if(arr[i]>arr[i+1]){

                                   inttemp = arr[i];

                                   arr[i]= arr[i+1];

                                   arr[i+1]= temp;

                          }      

                  }

                  //把老四放在倒数第四个位置上。

                  for(inti = 0 ;  i <arr.length-1-3 ; i++){

                          if(arr[i]>arr[i+1]){

                                   inttemp = arr[i];

                                   arr[i]= arr[i+1];

                                   arr[i+1]= temp;

                          }      

                  }

                  //遍历数组，查看效果

                  System.out.print("目前的元素：");

                  for(int i = 0 ; i<arr.length  ;i++){

                          System.out.print(arr[i]+",");

                  }

         }

}

采用双重循环的方式进行排序：

for(int j = 0 ; j<arr.length-1 ; j++){//控制轮数

                          for(inti = 0 ; i<arr.length-1-j  ; i++){  //找出一个最大值 

                                   //相邻的元素比较

                                   if(arr[i]>arr[i+1]){

                                            inttemp  = arr[i];

                                            arr[i]= arr[i+1];

                                            arr[i+1]= temp;

                                   }

                          }

                  }

折半查找（二分法）

需求：定义一个函数接收一个数组对象和一个要查找的目标元素，函数要返回该目标元素在

数组中的索引值，如果目标元素不存在数组中，那么返回-1表示。

折半查找法(二分法):使用前提必需是有序的数组。

class Demo12

{

         publicstatic void main(String[] args)

         {

                  int[]arr = {12,16,19,23,54};

                  //intindex = searchEle(arr,23);

                  intindex = halfSearch(arr,116);

                  System.out.println("元素所在的索引值是："+index);

         }

         publicstatic int halfSearch(int[] arr, int target){

                  //定义三个变量分别记录最大、最小、中间的查找范围索引值

                  intmax = arr.length-1;

                  intmin = 0;

                  intmid = (max+min)/2;

                  while(true){

                          if(target>arr[mid]){

                                   min= mid+1;

                          }elseif(target<arr[mid]){

                                   max= mid -1;

                          }else{

                                   //找到了元素

                                   returnmid;

                          }

                          //没有找到的情况

                          if(max<min){

                                   return-1;

                          }

                          //重新计算中间索引值

                          mid= (min+max)/2;

                  }

         }

         publicstatic int searchEle(int[] arr, int target){

                  for(inti = 0 ; i<arr.length ; i++){

                          if(arr[i]==target){

                                   returni;

                          }

                  }

                  return-1;

         }

}