剑指offer之链表

总结：链表增删改查，重点找到相应的节点，以及特殊情况的处理（链表为空，一个节点情况，尾节点情况）

package jzoffer;

import java.util.ArrayList;
import java.util.Scanner;
import java.util.Stack;

public class LinkList
{
    Node head = new Node();
    public void addNode(int data){//从末尾添加元素
        Node newNode = new Node(data),current = head;
        if(head.next ==null) {
            head = new Node();
            head.next = newNode;
        }
        else {
            while (current.next != null) {//从第一个节点开始判断，非空，再赋值后移
                current = current.next;
            }
            current.next = newNode;
        }
    }
    public  void  deleteNode(int target){//删除目标元素
        Node current = head;
        if (head.next == null) {
            System.out.println("链表为空，无法删除");
            return;
        }
        while(current.next != null){
            if(current.next.data == target){
               current.next = current.next.next;
               System.out.println("已成功删除节点:"+target);
               return;
            }
            current = current.next;
        }
        System.out.println("该元素不存在无法删除！");
    }
    public boolean  searchNode(int target){//查询目标元素是否存在
        Node current = head;
        if(head.next == null) {
            System.out.println("链表为空，无法查找！");
            return false;
        }
        while(current.next != null){
            if (current.next.data == target){
                System.out.println("查找到节点"+target);
                return true;
            }
            current = current.next;
        }
        return false;
    }

    public void printLinkList(){
        Node current = head;
        if(head.next == null) {
            System.out.println("链表为空，无法打印");
            return;
        }
        System.out.println("链表打印：");
        while(current.next != null){//从第一个节点开始判断，非空，再赋值后移
            current = current.next;
            System.out.println(current.data);
        }
    }
    class Node{
        int data;
        Node next;

        public Node(){
            this.data = data;
        }

        public Node(int data){
            this.data = data;
        }
    }

    //面试题4:输入一个链表，从尾到头打印链表每个节点的值
    //利用栈后进先出的特性

    public class ListNode {
        int val;
        ListNode next = null;

        ListNode(int val) {
            this.val = val;
        }
    }
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        Stack<Integer> stack = new Stack<>();
        while(listNode != null){
            stack.push(listNode.val);
            listNode = listNode.next;
        }
        ArrayList<Integer> list = new ArrayList<>();
        while (!stack.empty()){
           list.add(stack.pop());
        }
        return list;
        
    }
    public static void main(String args[]){
        LinkList linkList = new LinkList();
        Scanner cin = new Scanner(System.in);
        int num = cin.nextInt();
        while(num != -1){
            linkList.addNode(num);
            num = cin.nextInt();
        }
        linkList.deleteNode(5);
        System.out.println(linkList.searchNode(3));
        linkList.printLinkList();
    }

}

补充：

面试题18

题目1：在给定单向链表的头指针和一个节点指针（指向要删除的节点），在O（1）时间删除链表的节点

思路：分为三种情况

1、链表为空或要删除的节点为空，返回提示

2、要删除的节点不是尾节点，将要删除的节点（current）的下一个节点（current.next）的值都赋给current，然后直接删除current

3、要删除的节点是为尾节点，找到尾部节点，正常删除。

题目2：在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

 思路：设置指针temp指向当前节点，判断若当前节点不等于下一个节点，则将temp节点赋给index，若相等，则将temp移动到不重复节点处再赋给index

 public ListNode deleteDuplication(ListNode pHead)
    {
            ListNode result;
            ListNode temp=pHead;//当前负责移动判断的节点,这里头结点即为第一个节点
            ListNode index=new ListNode(1);//指向目前为止未重复的节点
            index.next=pHead;
            result=index;
            while(temp!=null){
                if(temp.next!=null&&temp.next.val==temp.val){//判断当前节点和下一个节点是否相等，若相等，则移动并找到不相等为止的节点
                    while(temp.next!=null&&temp.next.val==temp.val){
                        temp=temp.next;
                    }
                    temp=temp.next;//最后一个重复节点的下一个节点
                    index.next=temp;
                }
                else{
                    index=index.next;
                    temp=temp.next;
                }
            }
            return result.next;
    }

 面试题22：输入一个链表，输出该链表中倒数第k个结点。

思路：设置两个指针first和second，first走到第k个节点的时候，second在第一个节点处，接着同时向后移动

注意特殊情况的处理：

1. 链表为空状态，或者k<=0情况，返回空节点
2. k大于链表长度的情况，返回空节点，在第一个while循环结束后若k>1则链表长度小于k。

    public ListNode FindKthToTail(ListNode head,int k) {
        ListNode first = head,second = head;
        if(head == null || k <= 0) {
            return null;}
        while(k > 1 && first.next != null){
            first = first.next;
            k--;
        }
        if(k == 1){
            while(first.next != null){
                first = first.next;
                second = second.next;
            }
        }
        else second = null;
        return second;
    }

 面试题23：链表中环的路口

思路：将问题分为两个步骤（将复杂问题分解成多个步骤）

1. 找出环中任意一个节点：设置两个指针fast和low，fast每次走两步，low走一步，当两个指针相遇的时候，一定是在环中相遇。（注：当遇到尾节点的时候说明无环，则返回null）
2. 找到环的入口节点：fast回到头结点，low不变，连个结点每次同时走一步，相遇时则为环的入口节点。（可证明）

public ListNode EntryNodeOfLoop(ListNode pHead)
{
        ListNode fast = pHead,low = pHead;
        if(pHead == null || pHead.next == null) return null;
        while(fast != null && fast.next != null){
                low = low.next;
                fast = fast.next.next;
                if(low == fast){    //找到相遇节点时
                    fast = pHead;   //fast回到头结点
                    while(fast != low){
                        fast = fast.next;
                        low = low.next;
                    }
                    return low;
                }
            }
        return null;
}

 面试题24：输入一个链表，反转链表后，输出链表的所有元素

思路：分两种情况（链表为空或只有一个节点，链表不止一个节点）

public ListNode ReverseList(ListNode head) {
        ListNode current = head,pre = null,pnext = null,newHead = null;
        if(head == null || head.next == null) return head;
        while(current!= null){
            pnext = current.next;
            if(pnext == null) newHead = current;//一旦发现下一个节点为空，当前节点为最终头结点
            current.next = pre;
            pre = current;
            current = pnext;
        }
        return newHead;
    }

面试题25：输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

思路：每次都将两个链表的头部进行比较，小的看成是新的头结点，头节点的下一个节点就是新的merge，使用递归

           注意任意一个链表为空的状态

public ListNode Merge(ListNode list1,ListNode list2) {
        if(list1 == null) return list2;
        if(list2 == null) return list1;
        ListNode pmHead = null;
        if(list1!= null && list2 !=null){
            if(list1.val <= list2.val){
                pmHead = list1;
                pmHead.next = Merge(list1.next,list2);
            }
            else
            {
                pmHead = list2;
                pmHead.next = Merge(list1,list2.next);
            }
        }
        return pmHead;
        
    }

 面试题24：输入两个链表，找出它们的第一个公共结点。（y型）O（m+n）：节省空间

思路：分别计算两个链表的长度，根据长度的差值，长的链表先走差值的步数，然后两个链表同时移动对比。

   注意空链表情况以及无公共节点的情况。

另一种思路：使用两个栈分别存放两个链表的节点，从尾部向前比较，返回最后一个公共节点。O（m+n）

public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        if(pHead1 == null || pHead2 == null)  return null;
        ListNode current = pHead1,current1;
        int num1 = 0,num2 = 0;
        while(current != null){
            num1++;
            current = current.next;
        }
        current = pHead2;
        while(current != null){
            num2++;
            current = current.next;
        }
        if(num1 > num2) {
            num1 = num1 - num2;
            current = pHead1;
            current1 = pHead2;
        }else{
            num1 = num2 - num1;
            current = pHead2;
            current1 = pHead1;
        }
        while(num1 > 0){
            current = current.next;
            num1 --;
        }
        while(current !=null && current1 !=null){
            if(current == current1) return current;
            else{
                current = current.next;
                current1 = current1.next;
            }
        }
        return null;
    }
}