简单的算法总结

先来张总表来说明下各个算法的复杂度

冒泡排序

原理

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

实现

/**
* 冒泡排序
* @param a 数组a
* @return 返回排序后的数组
*/
public static int[]  bubleSort(int a[]) {

   for (int i=0;i<a.length;i++) {
       for (int j=i+1;j<a.length;j++) {
           if (a[i] < a[j]) {
               int temp = a[i];
               a[i] = a[j];
               a[j] = temp;
           }
       }
   }
   return a;
}

选择排序

原理

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完

实现

/**
 * 选择排序
 * @param a 数组a
 * @return 返回排序后的数组a
 */
public static int[] selectionSort(int a[]) {

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

        int index = i;
        for (int j=i+1;j<a.length;j++) {
            if (a[index]< a[j]) {
                //记录最小值
                index = j;
            }
        }

        if (i!=index) {
            int temp = a[i];
            a[i] = a[index];
            a[index] = temp;
        }
    }

    return a;
}

直接插入排序

原理

将n个元素的数列分为已有序和无序两个部分，如下所示：
{{a1}，{a2，a3，a4，…，an}}
{{a1⑴，a2⑴}，{a3⑴，a4⑴ …，an⑴}}
…
{{a1(n-1），a2(n-1) ，…},{an(n-1)}}

实现

public static int[] insertSort(int[] a) {
     //设定好下标0就是排序好的一个数组
     for (int i=1;i<a.length;i++) {
         int j= i-1;
         int k = a[i];
         while (j>-1 && k<a[j]) {
             //移动j，空出一个位置
             a[j+1] = a[j];
             j--;
         }
         a[j+1] = k;
     }
     return a;
}

快速排序

原理

1. 设置两个变量i、j，排序开始的时候：i=0，j=N-1
2. 以第一个数组元素作为关键数据，赋值给key，即key=A[0]
3. 从j开始向前搜索，即由后开始向前搜索(j–)，找到第一个小于key的值A[j]，将A[j]和A[i]互换
4. 从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换
5. 重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）

实现

/**
 * 快速排序
 * @param a 数组a
 * @param left 左边
 * @param right 右边序号
 * @return 排序后的数组
 */
public static int[] quickSort(int a[], int left, int right) {

    if (left < right) {
        int i = left, j = right, target = a[left];

        while (i<j) {

            while (i<j && a[j] < target) {
                j--;
            }
            if (i<j) {
                int temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }

            while (i<j && a[i] > target) {
                i++;
            }
            if (i<j) {
                int temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }
        }
        quickSort(a, left, i - 1);
        quickSort(a, i + 1, right);
    }
    return a;
}

归并排序

原理

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
4. 重复步骤3直到某一指针超出序列尾 将另一序列剩下的所有元素直接复制到合并序列尾

其实上面这么说还是有点乱，大体的意思就是先两两排序，再合并 如图：

实现

/**
 * 归并排序
 * 简介:将两个（或两个以上）有序表合并成一个新的有序表 即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列
 * 时间复杂度为O(nlogn)
 * 稳定排序方式
 * @param nums 待排序数组
 * @return 输出有序数组
 */
public static int[] sort(int[] nums, int low, int high) {
    int mid = (low + high) / 2;

    if (low < high) {
        // 左边
        sort(nums, low, mid);
        // 右边
        sort(nums, mid + 1, high);
        // 左右归并
        System.out.println(low+","+mid+","+high);
        merge(nums, low, mid, high);

    }
    return nums;
}

public static void merge(int[] nums, int low, int mid, int high) {
    int[] temp = new int[high - low + 1];
    int i = low;// 左指针
    int j = mid + 1;// 右指针
    int k = 0;
    // 把较小的数先移到新数组中
    while (i <= mid && j <= high) {
        if (nums[i] < nums[j]) {
            temp[k++] = nums[i++];
        } else {
            temp[k++] = nums[j++];
        }
    }


    // 把左边剩余的数移入数组
    while (i <= mid) {
        temp[k++] = nums[i++];
    }

    // 把右边边剩余的数移入数组
    while (j <= high) {
        temp[k++] = nums[j++];
    }
    printSort(temp);
    System.out.println("sss");

    // 把新数组中的数覆盖nums数组
    for (int k2 = 0; k2 < temp.length; k2++) {
        nums[k2 + low] = temp[k2];
    }
    printSort(nums);
    System.out.println("kkk");
}