薯薯的算法日记03

哈希表的一些常见用法

public static void main(String[] args) {
        TreeMap<Integer, String> treeMap1 = new TreeMap<>();
        treeMap1.put(7, "我是7");
        treeMap1.put(5, "我是5");
        treeMap1.put(4, "我是4");
        treeMap1.put(3, "我是3");
        treeMap1.put(9, "我是9");
        treeMap1.put(2, "我是2");
        System.out.println(treeMap1.containsKey(5));
        System.out.println(treeMap1.get(5));
        System.out.println(treeMap1.firstKey() + "我最小");
        System.out.println(treeMap1.lastKey() + "我最大");
        System.out.println(treeMap1.floorKey(8) + "在表中<=8的数中我离8最近");
        System.out.println(treeMap1.ceilingKey(8) + ">=8中我离8最近");
    }

链表

第一种方法我们依次把链表内容放入栈中然后从栈中弹出一个去比对，每一步一步去比对。

 public static boolean isPalindrome1(Node head){
        Stack<Node> stack = new Stack<Node>();
        Node cur = head;
        while(cur!=null){
            stack.push(cur);
            cur=cur.next;
        }
        while(head!=null){
            if(head.value!=stack.pop().value){
                return false;
            }
            head=head.next;
        }
        return true;
    }

第二种用快慢指针只折一半 去放进栈中 这样空间复杂度可以少一半 

对于快慢指针 满指针如何压中中间位置或者中间偏左位置（留着后续更~~ ）

不使用额外空间

public static boolean isPalindrome2(Node head) {
        if (head == null || head.next == null) {
            return true;
        }
        Node n1 = head;
        Node n2 = head;
        while (n2.next != null && n2.next.next != null) {
            n1 = n1.next;
            n2 = n2.next.next;
        }
        n2 = n1.next;
        n1.next = null;
        Node n3 = null;
        while (n2 != null) {
            n3 = n2.next;
            n2.next = n1;
            n1 = n2;
            n2 = n3;
        }
        n3 = n1;
        n2 = head;
        boolean res = true;
        while (n1 != null && n2 != null) {
            if (n1.value != n2.value) {
                res = false;
                break;
            }
            n1 = n1.next;
            n2 = n2.next;
        }
        n1 = n3.next;
        n3.next = null;
        while (n1 != null) {
            n2 = n1.next;
            n1.next = n3;
            n3 = n1;
            n1 = n2;
        }
        return res;
    }

 思路就是运用快慢指针 满指针指向中间的时候 把中间值改为null 并且使右边链表依次向左指 依次判断是否相同  最后再逆序回来（记下来 日常慢慢啃 一定要分析边界为什么这样写）

设置一个链表 给出一个num 让链表小于num的放左边 等于放中间 大于放右边

第一种方法 放进数组中partation 然后再返回 （没有稳定性）

第二种方法 设置六个变量 小于头尾 等于头尾 大于头尾 然后依次连接  注意判断不存在情况

public static Node listPartition2(Node head, int pivot) {
        Node sH = null;
        Node sT = null;
        Node eH = null;
        Node eT = null;
        Node mH = null;
        Node mT = null;
        Node next = null;
        while (head != null) {
            next = head.next;
            head.next = null;
            if (head.value < pivot) {
                if (sH == null) {
                    sH = head;
                    sT = head;
                } else {
                    sT.next = head;
                    sT = head;
                }
            } else if (head.value == pivot) {
                if (eH == null) {
                    eH = head;
                    eT = head;
                } else {
                    eT.next = head;
                    eT = head;
                }
            } else {
                if (mH == null) {
                    mH = head;
                    mT = head;
                } else {
                    mT.next = head;
                    mT = head;
                }
            }
            head = next;
        }
        if (sT != null) {//如果有小于区域
            sT.next = eH;
            eT = eT == null ? sT : eT;//下一步谁去连大于区域的头谁就是eT
        }
        if (eT != null) {
            eT.next = mH;
        }
        return sH != null ? sH : (eH != null ? eH : mH);
    }