数组排序

/*数组的排序： 将数组的所有元素按照一定的顺序进行排列*/
class ArraySortTest{
     public static void main(String args[]){
          int[] arr = {28,56,1,19,365,243,78,9}; 
          print(arr);
          //测试选择排序
          selectSort(arr); 
          System.out.println("选择排序后的结果：");
          print(arr);
  
          /*测试冒泡排序
         bubbleSort(arr);
         System.out.println("冒泡排序后的结果：");
         print(arr);*/

         /*测试插入排序  */
         insertSort(arr);
         System.out.println("插入排序后的结果：");
         print(arr);
  
         /*测试二分法查找  */
         int pos = binarySearch(arr,222);
         if(pos==-1){
               System.out.println("没有该元素");
               return; 
         }
         System.out.println("该元素的位置为：" + pos);
     }

     /*选择排序
     思路：
     1.定义一个外层循环，每次循环将最大数依次放在0~length-2的位置，
      用i变量来表示每次最大数应该在的位置，  i: 0~length-2
      每次循环要做两件事，找最大数、换位置
      2.定义一个内层循环，找出从当前位置到末尾所有元素中的最大数
      假设最大数为i，定义一个变量max=arr[i]记住最大数
      定义一个pos记住最大数所在的角标
      用j来遍历数组， j:i+1~length-1 */
     static void selectSort(int[] arr){
           for(int i=0; i<arr.length-1; i++) {
                  //找最大数
                  int max = arr[i];  
                  int pos = i; 
                  for(int j=i+1; j<arr.length; j++){
                       if(arr[j]>max) {
                              max = arr[j]; //为了下一次比较 
                              pos = j; //为了记住最大数的角标
                       } 
                  }
                //换位置 
                exchange(arr, i, pos);
           }
     }
 
       /*冒泡排序
      1.定义一个外层循环，每次将最轻的数放在当前位置i  i：0~length-2
      2.定义一个内层循环，从最末尾开始一直到当前元素的下一个位置，所有的元素都和它前一个元素进行冒泡
      比较大小，如果当前元素比前一个小，就交换位置，否则就不动
       j： length-1~i+1   每次比较  j和j-1去比 */
      static void bubbleSort(int[] arr){
           for(int i=0; i<arr.length-1; i++) {
                for(int j=arr.length-1; j>i; j--){
                      if(arr[j]<arr[j-1])
                      exchange(arr, j, j-1); 
                 }
           }
      }
 
       /*插入排序
      1.定义一个外层循环，每次循环搞定一个元素的正确位置， 从第二个元素开始到末尾，每次搞定第i个位置的元素，  i:1~length-1
      2.定义一个内层循环，将第i个元素摆放到一个它应该在的位置，不停地和前面一个元素比较，如果小就换位置，直到碰上比它还小的就不用再往前比了
          由于循环的次数不确定，应该用while循环，定义一个变量pos来记住该元素的角标，初始值为i
          停止条件：arr[pos]>arr[pos-1]、pos=0
          while循环的条件： pos!=0&&arr[pos]<arr[pos-1]*/
       static void insertSort(int[] arr){
               for(int i=1; i<arr.length; i++){
                     int pos = i;
                     while(pos!=0&&arr[pos]<arr[pos-1]) {
                              exchange(arr, pos, pos-1);
                               pos--; 
                      } 
               } 
        }
 
       /*二分法查找(折半查找)：  返回元素所在的角标位置
      查找数组中是否包含某个元素，专门针对按照升序排列的数组进行查找的，效率很高
      1.定义一个变量min记住开始位置0，定义一个变量max记住末尾位置length-1
      2.定义一个变量mid记住每次的折半位置，用于和要找的数去比较
      3.循环的次数不确定，定义一个while循环，知道min和max擦肩而过，条件是max>=min
      4.mid=(min+max)/2，找到折半位置
      5.判断要找的数和arr[mid]的大小
      6.大： min = mid+1   小： max = mid-1  相等： return mid;
      7.循环结束程序仍然没有返回，说明相等的情况根本没有发生过，那一定是没有该元素，我们return -1;说明没有找到*/
      static int binarySearch(int[] arr, int num){
             int min = 0;
             int max = arr.length-1;
             int mid = 0;
             while(max>=min){
                    mid = (min+max)/2;
                    if(num>arr[mid])
                          min = mid + 1;
                    else if(num<arr[mid])
                          max = mid - 1;
                    else
                          return mid; 
              } 
             return -1;
      }
 
      //交换元素的位置
      static void exchange(int[] arr, int pos1, int pos2){
             int temp = arr[pos1];
            arr[pos1] = arr[pos2];
            arr[pos2] = temp; 
      }
 
      //输出数组
      static void print(int[] arr){
              StringBuffer sb = new StringBuffer();
              for(int i=0; i<arr.length; i++)
                   sb.append(arr[i] + " ");
              System.out.println(sb); 
       }
}