java中常用的算法，android中常用的算法（冒泡排序算法、希尔排序算法等）

package a;

public class C {

public static void main(String[] args) {
// TODO Auto-generated method stub

      

        int arr[]={1,233,23,21,5,8,5,3};

          int arr2[]= sortShell(arr);

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

         System.out.print(arr2[i]+" ");
}
}

//冒泡排序算法
public static int[] sortBubble(int[] array){
    int temp;
    // 第一层循环:表明比较的次数, 比如 length 个元素,比较次数为 length-1 次（肯定不需和自己比）
    for(int i=0;i<array.length-1;i++){
         for (int j = array.length - 1; j > i; j--) {
               if (array[j] < array[j - 1]) {
                    temp = array[j];
                    array[j] = array[j - 1];
                    array[j - 1] = temp;
               }
         }
    }
    return array;
}

//选择排序算法
/*
* 选择排序的基本思想是遍历数组的过程中，以 i 代表当前需要排序的序号，
* 则需要在剩余的 [i…n-1] 中找出其中的最小值，然后将找到的最小值与 i 
* 指向的值进行交换。因为每一趟确定元素的过程中都会有一个选择最大值的子流程
* ，所以人们形象地称之为选择排序。选择排序的时间复杂度和空间复杂度分别为
*  O(n2 ) 和 O(1) 。
* */
public static int[] sortSelect(int[] arr){
     for (int i = 0; i < arr.length; i++) {
           int miniPost = i;
           for (int m = i + 1; m < arr.length; m++) {
                 if (arr[m] < arr[miniPost]) {
                       miniPost = m;
                 }
           }
 
           if (arr[i] > arr[miniPost]) {
                 int temp;
                 temp = arr[i];
                 arr[i] = arr[miniPost];
                 arr[miniPost] = temp;
          }
     }
     return arr;
}
//插入排序算法
/*插入排序的基本思想是在遍历数组的过程中，假设在序号 i 之前的元素即 [0..i-1] 
* 都已经排好序，本趟需要找到 i 对应的元素 x 的正确位置 k ，
* 并且在寻找这个位置 k 的过程中逐个将比较过的元素往后移一位，为元素 x 
* “腾位置”，最后将 k 对应的元素值赋为 x ，一般情况下，
* 插入排序的时间复杂度和空间复杂度分别为 O(n2 ) 和 O(1)。
* 
* */
public static int[] sortInsert(int[] array){
     for(int i=1;i<array.length;i++){
          int temp = array[i];
          int j;
          for(j=i-1;j >= 0 && temp< array[j]; j--){
               array[j + 1] = array[j];
          }
          array[j + 1] = temp;
     }
     return array;
}
//希尔排序算法
/*
 * 希尔排序的诞生是由于插入排序在处理大规模数组的时候会遇到需要移动太
 * 多元素的问题。希尔排序的思想是将一个大的数组“分而治之”，划分为若干
 * 个小的数组，以 gap 来划分，比如数组 [1, 2, 3, 4, 5, 6, 7, 8]
 *  ，如果以 gap = 2 来划分，可以分为 [1, 3, 5, 7] 和 [2, 4, 6, 8] 
 *  两个数组（对应的，如 gap = 3 ， 则划分的数组为：
 *   [1, 4, 7] 、 [2, 5, 8] 、 [3, 6] ）
 *   然后分别对划分出来的数组进行插入排序，
 *   待各个子数组排序完毕之后再减小 gap 值重复进行之前的步骤，
 *   直至 gap = 1 ，即对整个数组进行插入排序，此时的数组已经基本上快排好序了，
 *   所以需要移动的元素会很小很小，
 *   解决了插入排序在处理大规模数组时较多移动次数的问题，

希尔排序是插入排序的改进版，在数据量大的时候对效率的提升帮助很大，

数据量小的时候建议直接使用插入排序就好了。
 * */
public static int[] sortShell(int[] array) {
    // 取增量
    int step = array.length / 2;
    while (step >= 1) {
         for (int i = step; i < array.length; i++) {
              int temp = array[i];
              int j = 0;
              // 跟插入排序的区别就在这里
              for (j = i - step; j >= 0 && temp < array[j]; j -= step) {
                    array[j + step] = array[j];
              }
              array[j + step] = temp;
         }
         step /= 2;
    }
    return array;
}

}