java算法篇总结

标签：

1. 冒泡排序

   比较相邻元素，如果第一个比第二个大，那么交换他们的位置；每对相邻元素进行依次比较，最后的元素应该是最大的。

   int[] array = {10,13,12,8,11,6};
   
   //数组从小到大排序
   for (int i = 0; i < array.length - 1; i++) {
       for(int j = 0; j < array.length - i - 1;j ++){
           if (array[j] > array[j + 1]) {
               a = array[j];
               array[j] = array[j + 1];
               array[j + 1] = a;
           }
       }
   }
   System.out.println(Arrays.toString(array));//[6, 8, 10, 11, 12, 13]

2. 比较排序
   

   依次取数组中元素，跟之后元素进行比较，如果大于之后的元素，那么交换他们的位置，通过这种方式进行比较过后的数组就是一个从小到大排序的数组。

   //数组从小到大排序
   for (int i = 0; i < array.length; i++) {
       for(int j = i + 1; j < array.length;j ++){
           if(array[i] > array[j]){
               a = array[i];
               array[i] = array[j];
               array[j] = a;
           }
       }
   }
   System.out.println(Arrays.toString(array));//[6, 8, 10, 11, 12, 13]

3. 递归

   函数自身调用自身的方式称之为递归。

   public int[] sortArray(int[] array,int index){
       int a = 0;
       if(index <= array.length - 1){
           for(int i = index + 1; i < array.length;i ++){
               if(array[index] > array[i]){
                   a = array[index];
                   array[index] = array[i];
                   array[i] = a;
               }
           }
           sortArray(array,index + 1);
       }
       return array;
   }
   System.out.println(sortArray(array,0))

4. 二分查找

   二分查找速度快，数据源需要有序排列

   //查询11在数组中的下标
   int queryParam = 11;
   Arrays.sort(array);//排序
   int i = 0;
   int start = 0;
   int end = array.length - 1;
   while (start <= end) {
       i = (start + end) / 2;
       if (queryParam == array[i]) {
           System.out.println(i);
           break;
       } else if (queryParam < array[i]){
           end = i;
       } else if (queryParam > array[i]){
           start = i;
       }
   }

   
   

java算法篇总结

标签：

原文地址：http://my.oschina.net/haochenhh/blog/502406