标签：逻辑   void   strong   ++   输出   load   main   操作   相减   

线性查找

线性查找（1）

题目描述

LinearSearch

输入：数组，和目标元素

输出：目标元素所在的索引；若不存在，返回-1

代码实现

public class LinearSearch {
    /**
     * 查找数组中16所在的位置
     * @param data：数组
     * @param target：要查找的数据
     * @return
     */
    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 static void main(String[] args) {
        int[] data = {23, 54, 6, 42, 34, 16};
        int search = LinearSearch.search(data, 16);
        System.out.println(search);
    }

}

优化

基本思路

将具体的类型替换为 泛型 使其可以适应不同的类型

代码实现

public class LinearSearch {

    /**
     * 查找数组中16所在的位置
     *
     * @param data：数组
     * @param target：要查找的数据
     * @return
     */
    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;
    }

    public static void main(String[] args) {
        Integer[] data = {23, 54, 6, 42, 34, 16};
        int search = LinearSearch.search(data, 16);
        System.out.println(search);
    }

}

常见问题

将if判断中的 equals 改为 == 为什么不会报错？

int 的包装类就是 Integer，从 Java 5 开始引入了自动装箱/拆箱机制，使得二者可以相互转换。

排序算法

排序就是按照某种逻辑顺序重新排序的过程

选择排序

首先，找到数组中最小的那个元素，其次，将它和数组的第一个元素交换位置(如果第一个元素就是最小的元素那么它就和自己进行交换)。再次，在剩下的元素中找到最小的元素，将它与数组的第二个元素交换位置，如此往复，直到将整个数组排序。

public class SelectionSort {
    private SelectionSort(){}
    /**
     * 循环得到最小数
     * @param arr 无须数值
     */
    public static int[] sort(int[] arr) {
        // arr[0...i) 是有序的 arr[i...n) 是无序的
        for (int i = 0; i < arr.length; i++) {
            //最小 arr[i...n)
            int minNum = i;
            for (int j = i; j < arr.length; j++) {
                if (arr[j]<arr[minNum]){
                    minNum = j;
                }
            }
            swap(arr,i,minNum);
        }
        return arr;
    }

    /**
     * 赋值
     * @param arr 数值
     * @param i 当前索引
     * @param j 最小索引
     */
    public static void swap(int[] arr, int i, int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
    public static void main(String[] args) {
        int[] arr = {34,23,4235,43,1,344,53,45,41};

        System.out.println(sort(arr));

    }

}

插入排序法

其他

复杂度分析

时间复杂度就是用来方便开发者估算出程序的运行时间

我们该如何估计程序运行时间呢，我们通常会估计算法的操作单元数量，来代表程序消耗的时间， 这里我们默认CPU的每个单元运行消耗的时间都是相同的。

假设算法的问题规模为n，那么操作单元数量便用函数f(n)来表示

随着数据规模n的增大，算法执行时间的增长率和f(n)的增长率相同，这称作为算法的渐近时间复杂度，简称时间复杂度，记为 O(f(n))

复杂度分析：表示算法的性能、算法运行的上界

如：T= 5n + 2? T = c1 * n + c2 中c1，c2是常数

表示为O(n) 常数不重要，复杂度描述的是随着数据规模 n 的增大，算法性能的变化趋势

性能测试

基本思路

使用java的时间戳方法 System.nanoTime定义一个开始时间戳和一个结束时间戳相减得到我们需要的代码执行时间

实际演示

使用线性查找的方式进行性能测试

public class ArrayGennerator {
    private ArrayGennerator(){}

    public static Integer[] generateOrderedArray(int n){
        Integer[] arr = new Integer[n];
        for (int i = 0; i < n; i ++)
            arr[i] = i;
        return arr;
    }
}

public class LinearSearch {

    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;
    }

    public static void main(String[] args) {

        int[] dataSize = {100000, 1000000};
        for (int n : dataSize) {

            Integer[] data = ArrayGennerator.generateOrderedArray(n);

            
            long startTime = System.nanoTime();
            for (int k = 0; k < 100; k++)
                LinearSearch.search(data, n);
            long endTime = System.nanoTime();
            double time = (endTime - startTime) / 1000000000.0;
            System.out.println("n = " + n + ", 100 runs" + time + "s");
        }
    }
}

算法与数据结构(持续更新)

标签：逻辑   void   strong   ++   输出   load   main   操作   相减   

原文地址：https://www.cnblogs.com/south-wood/p/14341324.html