冒泡排序、选择排序、直接插入排序、二分法插入排序、希尔排序

算法
    特征：有穷性、确切性、输入项、输出项、可行性

算法运算要素：
    算术运算：加减乘除等运算
    逻辑运算：或、且、非等运算

    关系运算：大于、小于、等于、不等于等运算

    数据传输：输入、输出、赋值等运算

算法优劣评定
    时间复杂度、空间复杂度、正确性、可读性、健壮性

时间复杂度
    在计算机科学中，算法的时间复杂度是一个函数，它定性描述了该算法的运行时间。这是一个关于代表算法输入值的字符串的长度的函数。时间复杂度常用大O符号表述，不包括这个函数的低阶项和首项系数。

冒泡排序
public  void bubbleSort(int[] arr) {
        int temp;
        boolean outFlag = false;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    outFlag = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            if (!outFlag) {
                return;
            }
        }
 
    }
    

选择排序
public static void selectSort(int[]a)
{
    int minIndex=0;
    int temp=0;
    if((a==null)||(a.length==0))
        return;
    for(int i=0;i<a.length-1;i++)
    {
        minIndex=i;//无序区的最小数据数组下标
        for(intj=i+1;j<a.length;j++)
        {
            //在无序区中找到最小数据并保存其数组下标
            if(a[j]<a[minIndex])
            {
                minIndex=j;
            }
        }
        //将最小元素放到本次循环的前端
        temp=a[i];
        a[i]=a[minIndex];
        a[minIndex]=temp;
    }
}
 

 

直接插入排序
   public void sort(int[] arr) {
          int tmp;
          for(int i = 1; i < arr.length; i++) {
             // 待插入数据
              tmp = arr[i];
              int j;
              for(j = i - 1; j >= 0; j--) {
                  // 判断是否大于tmp，大于则后移一位
                  if(arr[j] > tmp) {
                     arr[j+1] = arr[j];
                 }else{
                     break;
                }
             }
             arr[j+1] = tmp;
         }
     }

二分法插入排序
public void binaryInsertionSort(int[] array) {
        printArray("原数组：", array);
        for (int i = 1; i < array.length; i++) {
            int temp = array[i];
            int right = i - 1;
            int left = 0;
            int mid;
            // 定位
            while (left <= right) {
                mid = (left + right) / 2;
                if (array[mid] > temp) {
                    right = mid - 1;
                } else if (array[mid] < temp) {
                    left = mid + 1;
                }
            }
            // 移动数组
            for (int j = i+1; j > left; j--) {
                array[j] = array[j - 1];
            }
            // 在找到的位置插入
        if(left!=i){ 
            array[left] = temp;
        }
            printArray("第" + time++ + "次循环排序结果: ", array);
        }
    }
希尔排序
public static void heerSort(int[]a)
{
        //希尔排序
        int d=a.length/2;
            while(true)
            {
                for(int x=0;x<d;x++)
                {
                    for(int i=x+d;i<a.length;i=i+d)
                    {
                        int temp=a[i];
                        int j;
                        for(j=i-d;j>=0&&a[j]>temp;j=j-d)
                        {
                            a[j+d]=a[j];
                        }
                        a[j+d]=temp;
                    }
                }
                if(d==1)
                {
                    break;
                }
        d--;//增量递减越大，效率越高越不稳定
            }
               printArray("第" + time++ + "次循环排序结果: ", a);
    }