Day13 LeeCode.队列.栈.哈希表

1.队列：1>先入先出；单端队列：一个口可以进，一个口可以出；

              2>时间复杂度：<1>访问时间复杂度O(N)；

                                        <2>搜索时间复杂度O(N)；

                                        <3>插入时间复杂度O(1)；

                                        <4>删除时间复杂度O(1)；

               3>常用操作：<1>创建队列：Queue<Integer> queue = new LinkedList<>();

                                     <2>添加元素：queue.add(1);

                                     <3>获取即将出队的元素：int temp1 = queue.peek();

                                     <4>删除即将出队的元素：int temp2 = queue.remove() / pop() / poll();

                                     <5>判断队列是否为空：queue.isEmpty(); // boolean

                                     <6>队列长度：queue.size();

                                     <7>遍历队列（边删除边遍历队列操作）：while(!queue.isEmpty()){

                                                                                                                int temp = queue.poll();

                                                                                                                System.out.println(temp);}

2.栈：1>先进后出；一个口进，一个口出；

           2>时间复杂度：<1>访问时间复杂度O(1)；

                                     <2>搜索时间复杂度O(N)；

                                     <3>插入时间复杂度O(1)；

                                     <4>删除时间复杂度O(1)；

           3>常用操作：<1>创建栈：Stack<Integer> stack = new Stack<>();

                                 <2>添加元素：stack.push(1);

                                 <3>查看栈顶元素：stack.peek();

                                 <4>删除栈顶元素：int temp = stack.pop();

                                 <5>栈的长度：stack.size();

                                 <6>栈是否为空：stacke.isEmpty();

                                 <7>遍历栈（边删除栈顶元素，边遍历）：while(!stack.isEmpty()){

                                                                                                                int num = stack.pop();

                                                                                                                System.out.println(num);}

3.哈希表：1>key：value 键值对   key -> 哈希函数 -> 内存地址 -> key/value 对应的内存地址

                     key不能重复，value可以重复；

                  2>时间复杂度：<1>访问时间复杂度X；

                                            <2>搜索时间复杂度O(1)；

                                            <3>插入时间复杂度O(1)；

                                            <4>删除时间复杂度O(1)；

                  3>常用操作：<1>创建哈希表：String[] hashTable = new String[4];

                                                                        // 明确数组的元素个数

                                                                    HashMap<Integer,String> map = new HashMap<>();

                                                                        //明确自带函数

                                        <2>添加元素：hashTable[1] = "1";

                                                                map.put(1,"1");

                                        <3>删除元素：hashTable[1] = "";

                                                                map.remove(1);

                                        <4>修改元素：hashTable[1] = "2";

                                                                map.put(1,"2");

                                        <5>获取key的值：String temp = hashTable[3];

                                                                      map.get(3); // key

                                        <6>检查key是否存在：map.containsKey(3); // key

                                        <7>哈希表长度：map.size();

                                        <8>哈希表是否含有元素：map.isEmpty();