Java算法入门-数组&链表&队列

算法就是解决问题的步骤，在一般的项目中可能用不上，但是一旦涉及到高并发，高性能时，就不得不考虑算法的优劣。

设计原则和特性

设计原则：正确性，可读性，健壮性，高效率和低存储

特性：有穷性，确定性，可行性，有输入，有输出。

算法题入门体验

如何判断是一个数是2的整数次幂？常规方法使用循环，但是在学习了二进制的基础知识后，发现可以使用模运算来实现。

import java.util.Scanner;

public class base {

    public static void main(String[] args) {
        /**
         * 算法入门，如何判断一个数是否为2的整数次幂，即是否为2^n
         * 如果不用算法就可以使用循环来实现
         * 如果使用算法，就可以考虑二进制的与运算
         */
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入需要计算的数字：");
        int num = scan.nextInt();
        method2(num);

    }

    /**
     * 使用循环来实现
     *
     * @param n
     */
    public static void methon1(int n) {
        while(true){
            n=n/2;
            if(n==2||n==1){
                break;
            }
        }
        if(n==2){
            System.out.println("这个数是2的整数次幂");
        }else{
            System.out.println("这个数不是2的整数次幂");
        }
    }

    /**
     * 使用二进制与运算来实现
     * @param n
     */
    public static void method2(int n){
        /**
         * 2的二进制10 1的二进制01 高位补齐
         * 4的二进制100 3的二进制011 高位补齐
         * 8的二进制1000 7的二进制0111 高位补齐
         * ...
         */
        int m=n&(n-1);

        if(m==0){
            System.out.println("这个数是2的整数次幂");
        }else{
            System.out.println("这个数不是2的整数次幂");
        }

    }
}

控制台输出情况

时间复杂度&空间复杂度

评价算法的两个重要的指标为时间复杂度和空间复杂度。

时间复杂度：运行一个程序需要的次数，一般用O()表示，一般有如下几种，具体可以参考代码。

（1）常数型，能确定循环的次数，一般为O(1)

（2）线性型，循环次数不确定，并且没有嵌套循环等，一般表示O(N)

（3）对数型，参考代码，一般表示为log(N)

（4）嵌套型，参考代码循环嵌套，一般表示为O(N^2)

注意使用时间复杂度表达式会省略低指数位，省略常数。

import java.util.ArrayList;
import java.util.List;

public class OCTest {

    public static void main(String[] args) {
        /**
         * 时间复杂度计算方法
         */

        //常数型
        int n=0; //O(1)
        int m=n+1; //O(1)
        for (int i = 0; i < 100; i++) {
            //有确定循环数目的，时间复杂度也是O(1)
        } //O(1)

        //线性型
        for (int i = 0; i < m; i++) {
            //循环次数不确定，就是线性型
        } //O(m)

        //对数型
        int c=1;
        while(c<=n){
            c=c*2;
            //循环结束就是2^m=n，这样使用高中数学知识就知道，m=log2^n，循环次数就是对数形式，在算法中就是写成log(n)
        } //O(log(n))

        //对数型
        for (int i = 0; i < n; i++) {
            int d=1;
            while(d<=n){
                d=d*2;
            }
        } //参考上面的例子，时间复杂度就是O(n*log(n))

        //下面嵌套的类型
        for (int i = 0; i <n ; i++) {
            for (int j = i; j < n; j++) {
                //当i=0，内存循环次数n次
                //当i=1，内存循环次数n-1
                //...
                //当i=n-1，内存循环次数为1
                //总的次数为上述等差数列之和n(n+1)/2,算法中去掉常数，只保留最高位后，时间复杂度变成O(n^2)
            }
        } // O(n^2)

        /**
         * 空间复杂度，表示占用内存
         */
        int j=0; //O(1)
        List<Integer> list=new ArrayList<Integer>();//默认容量大小为10，O(10)

    }
}

空间复杂度：运行一个程序所需要的额外耗费空间的数量就是空间复杂度，一般用OOM表示，或者用小O表示，即类似o(1)。如定义了3个变量，则空间复杂度为o(3*n^0)，去掉常数就是o(1)。

数据结构

数据结构是计算机存储和组织数据的方式，指相互之间存在一种或者多种特性关系的数据元素的集合。通常情况下，精心设计的数据结构可以带来更高的运行或者存储效率，如Btree用于MySql。数据结构跟高效的检索算法和索引技术有关，其中常见的数据结构有List，Set，Map和Queue，具体可以参考自己写的博客，持续添加中。

（1）List

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;

public class ListTest {

    public static void main(String[] args) {
        /**
         * 数组和链表
         */

        //List
        List<Integer> list=new ArrayList<Integer>();//底层是数组实现，是线程不安全的，访问快

        List<Integer> list1=new LinkedList<Integer>();//底层是一个链表，删除插入快

        //vector
        Vector<Integer> vector=new Vector<Integer>();//底层是一个数组，是线程安全的，多线程一般使用这个，但是性能相应的有损失
    }
}

（2）Set

public class SetTest {

    public static void main(String[] args) {
        /**
         * Set，主要用来去重的，Java有三种实现方式
         * 1 HashSet：去重的，去重后元素的顺序和插入的不一样
         * 2 TreeSet：排序的，底层数据结构为红黑树
         * 3 LinkedHashSet：维护了一个链表，保持插入和输出后的顺序一致
         */
    }
}

（3）队列

public class QueueTest {

    public static void main(String[] args) {
        /**
         * queue队列，用于等待队列，排队场景，如果一个系统流量高，需要做排队系统
         * MQ，消息队列
         *
         *
         * PriorityBlockingQueue：优先队列，如果实现一个排队场景，如有vip用户，可以让vip排在前面
         * 其他比较常用的队列有：
         * ArrayBlockingQueue 基于数组的阻塞队列，有界，不担心爆内存，take()一直会阻塞到有数据为止，可以用在高并发场景
         * LinkedBlockingQueue 无界的队列，可能会爆内存
         *
         * DelayQueue 延迟队列
         */

    }
}

常见数据结构优缺点

 

博客地址：

（1）https://www.cnblogs.com/youngchaolin/p/11032616.html 栈队列数组链表和红黑树

（2）https://www.cnblogs.com/youngchaolin/p/11028365.html Collection集合

（3）https://www.cnblogs.com/youngchaolin/p/10463887.html 二进制