11月5日leetcode刷题记录

1.反转链表

利用栈先进后出的特点，先把链表里的节点一个一个进栈，然后使用一个dummy节点保存出栈的第一个节点，之后遍历栈，把栈里面的节点一个一个拿出来链接起来。

public ListNode ReverseList (ListNode head) {
#第一步先创建一个空栈，需要用到java.util.Stack
Stack<ListNode> stack = new Stack<>();
#第二步，链表中的节点入栈
while(!head)
{
stack.push(head);
head = head.next;
}
##第三步，判断栈是否为空，也就是判断链表是否为空，如果为空，返回null
while(!stack.isEmpty())
{
return null;
}
##第四步，创建一个dummy节点保存出栈的第一个节点
ListNode node = stack.pop();
ListNode dummy = node;
##第五步，将出栈的节点连接起来
while(!stack.isEmpty())
{
    ListNode tempNode = stack.pop();
    node.next = tempNode;
    node = node.next;
}
node.next = null;
return dummy;
}

2.链表内指定区间反转

思路L：先找到要反转的前一个节点，然后使用头插法插入

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head ListNode类 
     * @param m int整型 
     * @param n int整型 
     * @return ListNode类
     */
    public ListNode reverseBetween (ListNode head, int m, int n) {
       //头插法实现
       //先添加一个虚拟头节点
       ListNode dummyNode = new ListNode(-1);
       dummyNode.next = head;
       ListNode p = dummyNode;
       ListNode g = head;
       //遍历，找到要插入的节点       
        for(int i=0;i<m-1;i++)
        {
            p = p.next;
            g = g.next;
        }
        //将g后面的节点删除，然后插入到p的后面，头插法遍历执行
        for(int i=0;i<n-m;i++)
        {
            ListNode removed = g.next;
            g.next = g.next.next;
            removed.next = p.next;
            p.next = removed;

        }
        return dummyNode.next;
 
}
}

3.链表中的节点每K个一组进行翻转

也是运用头插法，需要计算要反转多少次，每一组反转完成后需要更新g和p，g指向p，p指向p.next

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode g = dummy;
        ListNode p = dummy.next;
        int length = 0;
        while( head != null)
        {
            length++;
            head = head.next;
        }
        for(int i=0;i<length/k;i++)
        {
            for(int j=1;j<k;j++)
            {
                ListNode removed = p.next;
                p.next = p.next.next;
                removed.next = g.next;
                g.next = removed;
            }
            g = p;
            p = p.next;
        }
        return dummy.next;
}
}

4.合并两个有序的链表

创建一个新的链表接收数据，通过遍历，判断node1和node2的值的大小

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pHead1 ListNode类 
     * @param pHead2 ListNode类 
     * @return ListNode类
     */
    public ListNode Merge (ListNode pHead1, ListNode pHead2) {
        if(pHead1 == null)
        {
            return pHead2;
        }
        if(pHead2 == null)
        {
            return pHead1;
        }
        ListNode head = new ListNode(0);
        ListNode temp = head;
        while(pHead1!=null && pHead2!=null)
        {
            if(pHead1.val < pHead2.val)
            {
                temp.next = pHead1;
                pHead1 = pHead1.next;
            }
            else
            {
                temp.next = pHead2;
                pHead2 = pHead2.next;
            }
            temp = temp.next;
        }
        temp.next = pHead1!=null?pHead1:pHead2;
        return head.next;

    }
}