排序方式

冒泡排序:

int temp;//定义一个临时变量
        for(int i=0;i<arr.length-1;i++){//冒泡趟数
            for(int j=0;j<arr.length-i-1;j++){
                if(arr[j+1]<arr[j]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }

选择排序:

  int[] arr={1,3,2,45,65,33,12};
        System.out.println("交换之前：");
        for(int num:arr){
            System.out.print(num+" ");
        }        
        //选择排序的优化
        for(int i = 0; i < arr.length - 1; i++) {// 做第i趟排序
            int k = i;
            for(int j = k + 1; j < arr.length; j++){// 选最小的记录
                if(arr[j] < arr[k]){ 
                    k = j; //记下目前找到的最小值所在的位置
                }
            }
            //在内层循环结束，也就是找到本轮循环的最小的数以后，再进行交换
            if(i != k){  //交换a[i]和a[k]
                int temp = arr[i];
                arr[i] = arr[k];
                arr[k] = temp;
            }    
        }
        System.out.println();
        System.out.println("交换后：");
        for(int num:arr){
            System.out.print(num+" ");
        }
    }

二分查找:

1.递归的方式:

/**
  * 使用递归的二分查找
  *title:recursionBinarySearch
  *@param arr 有序数组
  *@param key 待查找关键字
  *@return 找到的位置
  */
 public static int recursionBinarySearch(int[] arr,int key,int low,int high){
  
  if(key < arr[low] || key > arr[high] || low > high){
   return -1;    
  }
  int middle = (low + high) / 2;    //初始中间位置
  if(arr[middle] > key){
   //比关键字大则关键字在左区域
   return recursionBinarySearch(arr, key, low, middle - 1);
  }else if(arr[middle] < key){
   //比关键字小则关键字在右区域
   return recursionBinarySearch(arr, key, middle + 1, high);
  }else {
   return middle;
  } 
 }

2.while循环实现:

/**
  * 不使用递归的二分查找
  *title:commonBinarySearch
  *@param arr
  *@param key
  *@return 关键字位置
  */
 public static int commonBinarySearch(int[] arr,int key){
  int low = 0;
  int high = arr.length - 1;
  int middle = 0;   //定义middle
  
  if(key < arr[low] || key > arr[high] || low > high){
   return -1;    
  }
  while(low <= high){
   middle = (low + high) / 2;
   if(arr[middle] > key){
    //比关键字大则关键字在左区域
    high = middle - 1;
   }else if(arr[middle] < key){
    //比关键字小则关键字在右区域
    low = middle + 1;
   }else{
    return middle;
   }
  }
  return -1;    //最后仍然没有找到，则返回-1
 }

3.测试代码:

public static void main(String[] args) {
 
  int[] arr = {1,3,5,7,9,11};
  int key = 4;
  //int position = recursionBinarySearch(arr,key,0,arr.length - 1);
  
  int position = commonBinarySearch(arr, key);
 
               if(position == -1){
   System.out.println("查找的是"+key+",序列中没有该数！");
  }else{
   System.out.println("查找的是"+key+",找到位置为："+position);
  }
  }