Java常用算法解析及示例（一）

本文章介绍一些常用的算法，使用Java语言解析，每个例子都有打印结果及每次循环排序的结构

1.冒泡排序
冒泡算法的主要逻辑是，假设有N个数，游标从第一位数开始，若左边的数比右边的数大，则左边交换，游标移向下一位直到最后一位。 在游标移动过程中，可以保证，右边的数一定比左边的数大，因为第一轮遍历是要找出最大的数， 并且最大的数在最后一位。同理，要找出第二大的数，重复上述过程，直至找出第N大的数，排序结束。 因此时间复杂度是O(N*N),空间复杂度是O(1)。
如果大家直接粘贴代码的话请把我的打印方法写上，如果是自己参考 请忽略 其他几个排序共用

    /**
     * 我是输出方法
     * @param count 排序轮数
     * @param arr 数组
     */
    public static void print(int count, int[] arr) {

        StringBuilder result = new StringBuilder();
        result = result.append("排序第").append(count).append("次，数组为:");

        System.out.println();

        for (int num : arr) {
            result = result.append(num).append(" ");
        }

        System.out.println(result);
    }

冒泡排序

    /**
     * 冒泡排序
     * 冒泡算法的主要逻辑是，假设有N个数，游标从第一位数开始，
     * 若左边的数比右边的数大，则左边交换，游标移向下一位直到最后一位。
     * 在游标移动过程中，可以保证，右边的数一定比左边的数大，因为第一轮遍历是要找出最大的数，
     * 并且最大的数在最后一位。同理，要找出第二大的数，重复上述过程，直至找出第N大的数，排序结束。
     * 因此时间复杂度是O(N*N),空间复杂度是O(1)。
     */
    public static void dropSort(int[] arr) {

        for (int i = 0; i < arr.length - 1; i++) {//外层循环控制排序趟数
            for (int j = 0; j < arr.length - 1 - i; j++) {//内层循环控制每一趟排序多少次
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            //数组角标从零开始
            print(i+1,arr);
        }

    }

2.选择排序
选择排序法 是对 定位比较交换法（也就是冒泡排序法） 的一种改进。
选择排序的基本思想是：每一趟在n-i+1（i=1，2，…n-1）个记录中选取关键字最小的记录作为有序序列中第i个记录。 基于此思想的算法主要有简单选择排序、树型选择排序和堆排序。
简单选择排序的基本思想：第1趟，在待排序记录r[1]~r[n]中选出最小的记录，将它与r[1]交换；
第2趟，在待排序记录r[2]~r[n]中选出最小的记录，将它与r[2]交换； 以此类推，第i趟在待排序记录r[i]~r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完毕。
选择排序算法的时间复杂度是O(n*n),空间复杂度为O(1)

    /**
     * 选择排序法
     * 选择排序法 是对 定位比较交换法（也就是冒泡排序法） 的一种改进。
     * 选择排序的基本思想是：每一趟在n-i+1（i=1，2，…n-1）个记录中选取关键字最小的记录作为有序序列中第i个记录。
     * 基于此思想的算法主要有简单选择排序、树型选择排序和堆排序。
     * 简单选择排序的基本思想：第1趟，在待排序记录r[1]~r[n]中选出最小的记录，将它与r[1]交换；
     * 第2趟，在待排序记录r[2]~r[n]中选出最小的记录，将它与r[2]交换；
     * 以此类推，第i趟在待排序记录r[i]~r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完毕。
     * 选择排序算法的时间复杂度是O(n*n),空间复杂度为O(1)
     */
    public static void choiceSort(int[] arr){

        for (int i = 0; i < arr.length - 1; i++) {//外层循环控制排序趟数

            //先记录指针 最后交换
            int index = i;

            for (int j = i+1; j < arr.length; j++) {

                //如果当前数大  则记录比较小的数的指针
                if (arr[index] > arr[j]) {
                    index = j;
                }
            }
            if (index != i){
                int temp = arr[index];
                arr[index] = arr[i];
                arr[i] = temp;
            }

            //数组角标从零开始
            print(i+1,arr);
        }

    }

3.直接插入排序
直接插入排序（Straight Insertion Sort）也称“简单插入排序”
基本思想：假设第一个数是有序的，则拿第二个跟第一个比较
第i趟排序将序列中第i+1个元素Ki+1插入到一个已经按值有序的子序列（K1，K2...Ki）中的合适的位置， 使得插入后的序列仍然保持按值有序, 直接插入排序算法的时间复杂度是O(n*n),空间复杂度为O(1)

    /**
     * 直接插入排序（Straight Insertion Sort）也称“简单插入排序”
     * 基本思想：假设第一个数是有序的，则拿第二个跟第一个比较
     * 第i趟排序将序列中第i+1个元素Ki+1插入到一个已经按值有序的子序列（K1，K2...Ki）中的合适的位置，
     * 使得插入后的序列仍然保持按值有序
     * 直接插入排序算法的时间复杂度是O(n*n),空间复杂度为O(1)
     */
    public static void insertSort(int[] arr){

        //放在外层 减少内存损耗
        int temp,j;

        for (int i = 1; i < arr.length; i++){

            //后面如果指针移动  那么数据将会变化 所以暂时存储起来
            temp = arr[i];
            //从有序的序列后端开始比较 如果tmpNum小于后端数，那后端的数要顺移
            for (j = i-1; j >= 0 && temp < arr[j]; j --){
                arr[j+1] = arr[j];
            }
            //将tmpNum插入到指定位置
            arr[j+1] = temp;
            //数组角标从零开始
            print(i+1,arr);
        }
    }

4.快速排序
快速排序的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
这个文章描述的非常仔细 如果理解不了可以去看一看 http://developer.51cto.com/art/201403/430986.htm

    /**
     * 快速排序
     * 快速排序的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，
     * 其中一部分的所有数据都比另外一部分的所有数据都要小，
     * 然后再按此方法对这两部分数据分别进行快速排序，
     * 整个排序过程可以递归进行，以此达到整个数据变成有序序列。
     * 这是文章描述的非常仔细 如果理解不了可以去看一看 http://developer.51cto.com/art/201403/430986.htm
     */
    public static void quickSort(int[] arr,int start,int end){

        //放在外层 减少内存损耗
        int temp,i,j = start;

        /*
         * 选择第一个数为基准数  所以要从末尾开始查找比基准数小的数
         * 这样后面才能 交换“相遇数（前后指针相遇的位置）”与基准数
         */
        for (i = end; i > start && i > j; i --){

            if (arr[i] < arr[start]){
                for (; j < i; j ++){
                    if (arr[j] >= arr[start]){
                        temp = arr[j];
                        arr[j] = arr[i];
                        arr[i] = temp;
                        break;
                    }
                }
            }

        }
        //如果移动到同一位置的话则与基准数交换
        if (i == j && i > start){
            temp = arr[start];
            arr[start] = arr[j];
            arr[j] = temp;
        }
        if (start != i){
            // 现在i处于分水岭  则不比较  对i前面的进行排序
            quickSort(arr,start ,i-1);
        }

        if (end!=i){
            // 现在i处于分水岭  则不比较  对i后面的进行排序
            quickSort(arr,i+1,end);
        }

        //数组角标从零开始
        print(i+1,arr);
    }

并附上Test 测试类

package com.study.studysummary.algorithm;

import org.junit.Before;
import org.junit.Test;

public class JavaAlgorithmTest {

    private static int[] args = {9, 1, 489, 79452, 4, 7, 214, 45, 12, 2, 3, 5, 87, 798, 13};

    @Before
    public void before(){
        JavaAlgorithm.print(0,args);
    }

    @Test
    public void testDropSort() {
        JavaAlgorithm.dropSort(args);
    }

    @Test
    public void testchoiceSort() {
        JavaAlgorithm.choiceSort(args);
    }

    @Test
    public void testInsertSort() {
        JavaAlgorithm.insertSort(args);
    }

    @Test
    public void testQuickSort() {
        JavaAlgorithm.quickSort(args,0,args.length -1);
    }

}

第一章先学到这里，如果大家有问题可以留言，或者到https://gitee.com/only-one-one/studysummary下载源码