为了转行程序员而努力的第二十六天-链表，重写，重载，多态

决定把每一篇文章的关键知识点放在标题，这样便于复习的时候查询，不用一篇一篇点开看。

又早醒了，虽然昨天看岗位信息看兴奋了，其实没有早睡，还是一醒来就不可避免地陷入低落情绪，但好在已经习惯了，对刷题也稍微放松一些了，没有之前那么紧张了。在地铁上读了几篇leetbook，工作间隙打开网课开始听，今天学的是链表。

强行听了三节网课，第三小节快结束的时候，午休时间已经过了一半了，实在是困得不行，最后几分钟都是在半睡半醒中听的。开始刷题反而不困了，越刷越兴奋，虽然才开始对如何实现链表很不熟悉，要看好几次答案才慢慢把bug修过来，确实链表测试很不方便，但是其实在看答案，消化思考，自己重写一遍的过程中，也学到了东西，通过重复的练习，可以减少陌生感，刷题开始没有那么痛苦了。

精神也要放松一些了，开始通过看书来作为调节，下午也通过工作来放松因为刷题而紧绷的神经，看来工作内容简单重复也不是没有好处的，不怎么需要动脑，还可以减压，但是单位时间强度很大甚至需要加班的简单重复劳动完全就是被压榨的血汗工人了。昨天父母还安慰我说，工作的头几年都是这样的，就是简单重复劳动，熬过去就好了，我说，你跟流水线上每天重复组装的工人讲，过几年就好了，总会熬出头的，你看他信不信，有的重复是没有多大收获的，为什么我不能去找一份其他的工作，非要在这里熬着等着出头呢（我们心里都知道几乎不可能出头），就算这些技能总有一天会有用的，为什么不能学习自己想要学习的技能呢。

今日进度：
1.坚持听课，坚持刷题
2.坚持锻炼，希望能完成每天的二十分钟训练和拉伸
3.提高晚上的效率，集中注意力
4.控制自己，晚饭少吃
5.坚持录小王子

学习笔记：
1.当需要在子类中调用父类的被重写方法时，要使用 super 关键字。
2.方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载 (Overloading)。
3.方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写 (Overriding)。
4.方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。
5.因为Deer类具有多重继承，所以它具有多态性。在Java中，所有的对象都具有多态性，访问一个对象的唯一方法就是通过引用型变量。

public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}

6.所有的引用型变量d,a,v,o都指向堆中相同的Deer对象。

Deer d = new Deer();
Animal a = d;
Vegetarian v = d;
Object o = d;

7.206. 反转链表
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

解题思路：操作每一个节点的next指针，pre,cur,next三个指针，当cur为空时，结束遍历，pre指针变为head，返回pre。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur;
        ListNode next;
        cur = head;
        if(cur == null){
            return null;
        }
        next = cur.next;
        while(cur != null){
           next = cur.next; 
           cur.next = pre;
           pre = cur;
           cur = next; 
        }
        return pre;
    }
}

8.92. 反转链表 II
给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。

输入：head = [1,2,3,4,5], left = 2, right = 4
输出：[1,4,3,2,5]

解题思路：记录left的前一个节点和right的后一个节点，将left到right部分的链表截取出来，翻转之后，再插入到原来的位置，注意截断的时候要将相关链接设为空值。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
        
        ListNode dummyNode = new ListNode(-1);//设置一个虚拟头
        dummyNode.next = head;
        ListNode pre = dummyNode;
        for(int i=0; i<left-1; i++){
            pre = pre.next;
        }//左边截断点
        ListNode rightN = pre;
        for(int i=0; i<right-left+1; i++){
            rightN = rightN.next;
        }//右边截断点
        ListNode leftN = pre.next;
        ListNode curr = rightN.next;
        pre.next = null;
        rightN.next = null;//截断链表
        reverse(leftN);
        pre.next = rightN;
        leftN.next = curr;
        return dummyNode.next;

    }

    public void reverse(ListNode head){
        ListNode pre = null;
        ListNode cur = head;
        while(cur != null){
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }

    }
}

9.83. 删除排序链表中的重复元素
存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除所有重复的元素，使每个元素 只出现一次 。
返回同样按升序排列的结果链表。

输入：head = [1,1,2]
输出：[1,2]

解题思路：使用查找表set存储链表的值，如果有重复，就将pre指针直接指向cur的下一个节点，相当于将现在的节点删除了

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        Set<Integer> s = new HashSet<Integer>();
        ListNode cur = head;
        ListNode pre = null;
        
        if(cur == null){
            return null;
        }
        while(cur != null){
            if(s.contains(cur.val)){
              
                if(cur != null){
                    pre.next = cur.next;
                } 
                cur = pre.next;
            }
            else{
                s.add(cur.val);
                pre = cur;
                if(cur != null){
                    cur = cur.next;
                }
            }
            
        }
        return head;
    }
}

10.86. 分隔链表
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。
你应当 保留 两个分区中每个节点的初始相对位置。

输入：head = [1,4,3,2,5,2], x = 3
输出：[1,2,2,4,3,5]

解题思路：设置两个链表，一个small存储比x小的数，一个large存储比x大的数，将small的末尾指向large的开头，将large的末尾指向null，可以设置两个节点分别指向small和large的头节点

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode partition(ListNode head, int x) {
        ListNode sw = new ListNode(0);
        ListNode lw= new ListNode(0);
        ListNode sh = sw;
        ListNode lh = lw;
        while(head != null){
            if(head.val < x){
                sw.next = head;
                sw = sw.next;
            }
            else{
                lw.next = head;
                lw = lw.next;
            }
            head = head.next;
        }
        sw.next = lh.next;
        lw.next = null;
        return sh.next;
    }
}

今天抽空看了一下王小波的沉默的大多数，还真就挺敢说的，也很有见地，今天留下了几道练习题328，2，445，203，82，21，这么一看还挺多的，不知道是不是链表的题数量比较多，明天加油刷题，明日持续更新。