编程导航算法通关村第二关|白银-CSDN博客

本文链接：https://blog.csdn.net/m0_62475528/article/details/131996139

指定区间反转

头插法

一个一个进行插入，利用虚拟结点。

public static ListNode reverseBetween(ListNode head, int left, int right){
    ListNode dummyNode=new ListNode(-1);
    dummy.next=head;
    ListNode pre=dummyNode;
    for(int i=0;i<left-1;i++)
        pre=pre.next;
    ListNode cur=pre.next;
    ListNode temp;
    for(int i=0;i<right-left;i++){
        temp=cur.next;
        cur.next=temp.next;
        temp.next=pre.next;
        pre.next=temp;
    }
    return dummyNode.next;
}

穿针引线法

先确定left，right，然后将待返转的区域反转，再将这三段链表进行连接。同样使用虚拟结点。

public static ListNode reverseBetween(ListNode head, int left, int right){
    ListNode dummyNode=new ListNode(-1);
    dummy.next=head;
    ListNode pre=dummyNode;
    for(int i=0;i<left-1;i++)
        pre=pre.next;
    ListNode rightNode=pre;
    for(int i=0;i<right-left+1;i++)
        rightNode = rightNode.next;
    ListNode leftNode = pre.next;
    ListNode succ = rightNode.next;
    //注意切断
    rightNode.next = null;
    //反转
    reverseList(leftNode);
    //链接三个链表
    pre.next = rightNode;
    leftNode.next = succ;
    return dummyNode.next;
    
}

两两交换链表中的结点

public static  ListNode swapPairs(ListNode head){
    ListNode dummyHead = new ListNode(0);
    dummyHead.next=head;
    ListNode temp= dummyHead;
    while(temp.next!=null&&temp.next.next!=null){
        ListNode node1=temp.next;
        ListNode node2=temp.next.next;
        temp.next=node2;
        node1.next=node2.next;
        node2.next=node1;
        temp=node1;
        return dummyHead.next;
    }
}

单链表加1

用栈来实现。其中adder不能用1 来代替。用过一次后要归零，因为会让之后每次都多加1。

public static ListNode plusOne(ListNode head) {
    Stack<Integer> st =new Stack();
    while(head!=null){
        st.push(head.val);
        head=head.next;
    }
    int carry=0;
    ListNode dummy=new ListNode(0);
    int adder=1;
    while(!st.empty()||carry >0){
        int digit=st.empty()?0:st.pop();
        int sum=digit+adder+carry;
        carry=sum>=10?1:0;
        sum=sum>=10?sum-10:sum;
        ListNode cur=new ListNode(sum);
        cur.next=dumm.next;
        dummy.next=cur;
        adder=0;//一定要让add等于0
    }
    return dummy.next;
}

链表加法

使用栈

public static ListNode addInList(ListNode head1, ListNode head2) {
    Stack<ListNode> st1 = new Stack<ListNode>();
    Stack<ListNode> st2 = new Stack<ListNode>();
    while (head1 != null) {
        st1.push(head1);
        head1 = head1.next;
    }
    while (head2 != null) {
        st2.push(head2);
        head2 = head2.next;
    }
    ListNode newHead = new ListNode(-1);
    int carry = 0;
    while (!st1.empty() || !st2.empty() || carry != 0) {
            ListNode a = new ListNode(0);
            ListNode b = new ListNode(0);
            if (!st1.empty()) 
                a = st1.pop();
            if (!st2.empty()) 
                b = st2.pop();
            //每次的和应该是对应位相加再加上进位
            int get_sum = a.val + b.val + carry;
            //对累加的结果取余
            int ans = get_sum % 10;
            //如果大于0，就进位
            carry = get_sum / 10;
            ListNode cur = new ListNode(ans);
            cur.next = newHead.next;
            //每次把最新得到的节点更新到neHead.next中
            newHead.next = cur;
        }
        return newHead.next;
}

使用链表反转

先将两个链表分别反转，计算完结果之后，再进行反转。

//略，看见链表就想吐现在

再论链表回文序列问题

快慢指针+一半反转

可以学完链表反转再来学习这个问题

//略，理由同上，等我缓一缓再写