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

 1 import java.util.Scanner;
 2 
 3 public class base {
 4 
 5     public static void main(String[] args) {
 6         /**
 7          * 算法入门，如何判断一个数是否为2的整数次幂，即是否为2^n
 8          * 如果不用算法就可以使用循环来实现
 9          * 如果使用算法，就可以考虑二进制的与运算
10          */
11         Scanner scan = new Scanner(System.in);
12         System.out.println("请输入需要计算的数字：");
13         int num = scan.nextInt();
14         method2(num);
15 
16     }
17 
18     /**
19      * 使用循环来实现
20      *
21      * @param n
22      */
23     public static void methon1(int n) {
24         while(true){
25             n=n/2;
26             if(n==2||n==1){
27                 break;
28             }
29         }
30         if(n==2){
31             System.out.println("这个数是2的整数次幂");
32         }else{
33             System.out.println("这个数不是2的整数次幂");
34         }
35     }
36 
37     /**
38      * 使用二进制与运算来实现
39      * @param n
40      */
41     public static void method2(int n){
42         /**
43          * 2的二进制10 1的二进制01 高位补齐
44          * 4的二进制100 3的二进制011 高位补齐
45          * 8的二进制1000 7的二进制0111 高位补齐
46          * ...
47          */
48         int m=n&(n-1);
49 
50         if(m==0){
51             System.out.println("这个数是2的整数次幂");
52         }else{
53             System.out.println("这个数不是2的整数次幂");
54         }
55 
56     }
57 }

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)

    }
}

 1 import java.util.ArrayList;
 2 import java.util.LinkedList;
 3 import java.util.List;
 4 import java.util.Vector;
 5 
 6 public class ListTest {
 7 
 8     public static void main(String[] args) {
 9         /**
10          * 数组和链表
11          */
12 
13         //List
14         List<Integer> list=new ArrayList<Integer>();//底层是数组实现，是线程不安全的，访问快
15 
16         List<Integer> list1=new LinkedList<Integer>();//底层是一个链表，删除插入快
17 
18         //vector
19         Vector<Integer> vector=new Vector<Integer>();//底层是一个数组，是线程安全的，多线程一般使用这个，但是性能相应的有损失
20     }
21 }

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

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