1算法学习_线性查找、选择排序、插入排序及优化方案

1. 什么是算法

算法：一系列解决问题的，清晰，可执行的计算机指令

1. 有限性 ：在一定的时间执行完成
2. 确定性：不会产生二义性
3. 可行性；这个算法是可以的
4. 输入
5. 输出

举例：比如一道菜，如何做这道菜，做这道菜的过程就是算法

2. 线性查找法

举例：如何在一堆试卷中，找到自己的试卷

/**
 * @ClassName LinearSearch
 * @description: 线性查找法
 * @author: qsong
 * @create: 2021-01-27 15:19
 * @Version 1.0
 **/
public class LinearSearch {

    private LinearSearch(){}

    public static void main(String[] args) {
        int [] data={24,18,12,9,16,66,32,4};
        int i = LinearSearch.search(data, 16);
        System.out.println(i);

    }
    /**
     * @Author qsong
     * @Description
     * @Date 下午3:22 2021/1/27
     * @Param
     * @return
     *
     *          // 输入 数组和目标元素
     *         //输出  目标元素锁在的索引；若不存在，返回-1
     **/
    public static int search(int[] data,int target ){
        for (int i=0; i<data.length;i++) {
            if (data[i]==target){
                return i;
            }
        }
        return -1;
    }
}

使用范型改造线性查找算法，适应所有类型：

注意：范型不可以是基本的数据类型，只能是类对象

public class LinearSearch {

    private LinearSearch(){}

    public static void main(String[] args) {
        Integer[] data={24,18,12,9,16,66,32,4};
        int i = LinearSearch.search(data, 16);
        System.out.println(i);

    }
    /**
     * @Author qsong
     * @Description
     * @Date 下午3:22 2021/1/27
     * @Param
     * @return
     *
     *          // 输入 数组和目标元素
     *         //输出  目标元素锁在的索引；若不存在，返回-1
     **/
    public static <E> int search(E[] data,E target ){
        for (int i=0; i<data.length;i++) {
            if (data[i].equals(target)){
                return i;
            }
        }
        return -1;
    }
}

3. 基础排序算法

排序算法：让数据有序

• 选择排序法

• 插入排序法

3.1 选择排序法

1. 先把小的拿出来

2. 剩下的，再把小的拿出来，排到上一个小的后面

3. 剩下的，再把小的拿出来，排到上一个小的后面

4. 。。。。。。

每次选择还没处理的元素里最小的元素。

举例：一个数组中存在 6 4 2 3 1 5，对它进行排序，

1. 先拿出1，然后剩下 6 4 2 3 5

2. 再拿出2，就变成1，2 ，然后剩下 6 4 3 5

3. 再拿出3 ，就变成1，2，3 ，然后剩下 6 4 5

4. 。。。。。以此类推

这种选择排序其实是开辟了一个新的空间，可否原地完成呢？

/**
 * @ClassName SelectionSortingMethod
 * @description: 选择排序法
 * @author: qsong
 * @create: 2021-01-28 11:30
 * @Version 1.0
 **/
public class SelectionSort {
    public static void main(String[] args) {
        Integer[] data={6,4,2,3,1,5};
        SelectionSort.sort(data);
        for (Integer result : data) {
            System.out.print(result +" ");
        }

    }

    /**
     * @Author qsong
     * @Description
     * @Date 上午11:31 2021/1/28
     * @Param
     * @return
     **/

    public static <E extends Comparable<E>> void sort(E[] data){
        for (int i=0;i< data.length;i++){
            for (int j = i+1; j< data.length;j++){
                if (data[i].compareTo(data[j])>=0 ){
                   E params=data[i];
                   data[i]=data[j];
                   data[j]=params;
                }
            }
        }
    }

}

注意：E范型需要继承Comparable这个接口，才能进行比较

3.2 插入排序法

1. 把第一个元素和第二个元素进行比较，小的放在前面，大的放在后面，如何前面没有数，开始下一位的比较
2. 第二位和第三位进行比较，如果第三位比第二位小，第三位往前移，第三位再跟第一位进行比较，大的放在后面，小的往前移
3. 以此类推。。。。。

注意：选择排序和插入排序很类似，但是选择排序，排序一段时间后，前面几位一定是最小的几位，但是插入排序并不是

/**
 * @ClassName InsertionSort
 * @description: 插入排序法
 * @author: qsong
 * @create: 2021-01-29 11:17
 * @Version 1.0
 **/
public class InsertionSort {
    private InsertionSort(){}

    public static void main(String[] args) throws Exception {
        Integer[] data={6,4,2,3,1,5};
        InsertionSort.sort(data);
        for (Integer result : data) {
            System.out.print(result +" ");
        }
        System.out.println();
        System.out.println("-------------------------------");
        SortingHelper.sortTest("InsertionSort",ArrayGenerator.generatorRandomArray(100,10000));

    }

    /**
     * @Author qsong
     * @Description 插入排序法
     * @Date 上午11:18 2021/1/29
     * @Param
     * @return
     **/
    public static  <E extends Comparable<E>> void sort(E[] data){
        //插入排序是第一位和第二位进行比较
        for (int i = 0; i < data.length; i++) {
            for (int j = i; j-1 >=0; j--) {
                if (data[j].compareTo(data[j-1])<0){
                    E params=data[j];
                    data[j]=data[j-1];
                    data[j-1]=params;
                }else{
                    break;
                } 
            }
        }
    }
}

优化：

/**
 * @Author qsong
 * @Description 插入排序法3
 * @Date 上午11:18 2021/1/29
 * @Param
 * @return
 **/
public static  <E extends Comparable<E>> void sort3 (E[] data){
    //插入排序是第一位和第二位进行比较
    for (int i = 0; i < data.length; i++) {
        //将data[i] 插入到合适的位置
        E params=data[i];
        int j;
        for (j = i; j-1 >=0 && params.compareTo(data[j-1])<0; j--) {
            //大于值，复制后移
            data[j]=data[j-1];
        }
        data[j]=params;
    }
}

倒序：

/**
 * @Author qsong
 * @Description 优化后的插入排序法
 * @Date 上午11:18 2021/1/29
 * @Param
 * @return
 **/
public static  <E extends Comparable<E>> void sort4 (E[] data){
    //倒数第一位和倒数第二位进行比较
    for (int i = data.length-1; i >= 0; i--) {
        //将data[i] 插入到合适的位置
        E params=data[i];
        int j;
        for (j = i; j+1 <data.length && params.compareTo(data[j+1])>0; j++) {
            //大于值，复制后移
            data[j]=data[j+1];
        }
        data[j]=params;
    }
}