单链表经典题型

首先创建一个链表类

class MySingleList<T> {
    private Node<T> head; //永远指向链表当中的第一个节点

    class Node<T>{

        public T getData() {
            return data;
        }

        private T data; //数据域名
        private Node<T> next; //next引用域

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

        public void setNext(Node<T> next){
            this.next = next;
        }

        public void setData(T data) {
            this.data = data;
        }


        public Node<T> getNext() {
            return next;
        }

    }

    public Node<T> createNode(T value){
        return new Node(value);
    }

1.不允许改变链表的结构，逆序输出链表

使用递归从后往前打印。

public static <T> void reversePrintList(MySingleList<T>.Node<T> head){
    if(head == null){
        return;
    }
    //相同的逻辑
    reversePrintList(head.getNext());
    System.out.println(head.getData());
}

2.改变链表结构实现逆置

即：逆置第二个节点时要保存节点二下一节点的值，否则将节点一二逆置后无法继续进行。

public static <T> MySingleList<T>.Node<T> reverseList(MySingleList<T>.Node<T> head){
    MySingleList<T>.Node<T> curNode = head;//当前绩点
    MySingleList<T>.Node<T> prev = null; //当前节点的前驱
    MySingleList<T>.Node<T> next = null; //当前节点的后继

    MySingleList<T>.Node<T> newHead = null; //逆置后链表的头
    while(curNode != null){
        next = curNode.getNext();
        if(next == null){
            newHead = curNode;
        }
        //改变curNode和prev之间的引用
        curNode.setNext(prev);
        //往后走
        prev = curNode;
        curNode = next;
    }
    return newHead;
}

3.不允许遍历链表，在pos节点之前插入一个新节点

即：先创建一个新的节点，将post值赋给新的节点，然后插入，再改变pos.data

public static <T> boolean insertPosBefore(MySingleList<T> list,  MySingleList<T>.Node<T> pos, T value){
    if(list.getHead() == null || pos == null){ //参数合法性判断
        return false;
    }
    //创建新节点
    MySingleList<T>.Node<T> newNode= list.createNode(pos.getData());
    //将新节点插入到pos之后
    pos.setNext(newNode);
    //改变pos.data
    pos.setData(value);
    return true;
}

4.查找单链表中倒数第k个节点

即：先让快的走K步，然后同时一起走，当快的走到表尾时，慢的刚好指向倒数第K个节点。

public static <T> MySingleList<T>.Node<T> findKNode1(MySingleList<T>.Node<T> head, int k){
    if(head == null){
        return null;
    }
    //定义两个引用
    //fast需要先走k-1步
    MySingleList<T>.Node<T> fast= head;
    //slow 最终指向目标节点
    MySingleList<T>.Node<T> slow = head;

    //k的合法性判断
    if (k <= 0) {
        return null;
    }

    //fast先走
    for(int i=0; i<k-1; i++){
        if(fast == null){
            return null;
        }
        fast = fast.getNext();
    }
    //front、slow同时走
    while(fast.getNext() != null){
        fast = fast.getNext();
        slow = slow.getNext();
    }
    return slow;
}

5.合并两个有序的链表，保证合并之后的链表依然有序

即：传入两个链表的头结点新建一个链表的头结点newHead，循环比较传入的两个链表的排序变量，谁小（这里按从小到大安排序）谁加到newHead的后边，如果有一个链表已经为空，那么就只是针对另一个链表进行添加即可，直到两个链表都为空。

public static <T extends Comparable<T>> MySingleList<T>.Node<T> mergeOrderList(MySingleList<T>.Node<T> head1, MySingleList<T>.Node<T> head2) {
 //类型擦除到Object类型，Object类型中没有提供比较大小的方法但是Comparable接口提供了，期望类型擦除到Comparable接口。泛型类型可以定义上界，通过extends关键字，使其擦除到上界所对应的类型
    if(head1 == null && head2 == null){
        return null;
    }else if(head1 == null){
         return head2;
    }else if(head2 == null){
        return head1;
    }
    //其中就可以使用compareTo方法比较大小
    //要求所传的泛型类型也必须要实现Compareable
    MySingleList<T>.Node<T> newHead = null;
    //确定合并后链表的头节点
    if (head1.getData().compareTo(head2.getData()) >= 0) {
        newHead = head2;
        head2 = head2.getNext();
    } else {
        newHead = head1;
        head1 = head1.getNext();
    }
    //遍历list1和list2，将对应位置更小的节点链到新链表之后
    //一旦list1和list2其中一个遍历完成，则直接链入另外一个未遍历完的链表
    MySingleList<T>.Node<T> tmp = newHead;
    while (head1 != null && head2 != null) {
        if (head1.getData().compareTo(head2.getData()) >= 0) {
            tmp.setNext(head2);
            //head2为更小的位置点，head2需要往后走
            head2 = head2.getNext();
            //tmp永远指向新链表尾巴
            tmp = tmp.getNext();
        } else {
            tmp.setNext(head1);
            //head1为更小的位置点，head1需要往后走
            head1 = head1.getNext();
            //tmp永远指向新链表尾巴
            tmp = tmp.getNext();
        }
    }

    if (head1 == null) {
        tmp.setNext(head2);
    }

    if (head2 == null) {
        tmp.setNext(head1);
    }
    return newHead;
}

6.两个链表相交，求出相交节点

public static <T>  MySingleList<T>.Node<T> commonNode1(MySingleList<T>.Node<T> head1, MySingleList<T>.Node<T> head2){
    if(head1 == null || head2 == null){
        return null;
    }
    //将两个链表中的元素进行入栈操作
    Stack<MySingleList<T>.Node<T>> stack1 = new Stack<>();
    Stack<MySingleList<T>.Node<T>> stack2 = new Stack<>();

    //list1
    MySingleList<T>.Node<T> tmp = head1;
    while(tmp != null){
        stack1.push(tmp);
        tmp = tmp.getNext();
    }
    //list2
    tmp = head2;
    while(tmp != null){
        stack2.push(tmp);
        tmp = tmp.getNext();
    }
    
    MySingleList<T>.Node<T> commonNode = null;
    while(stack1.peek() == stack2.peek()){
        commonNode = stack1.peek();
        stack1.pop();
        stack2.pop();
    }
    return commonNode;
}

7.判断一个链表是否有环，求出环的入口节点

//判断是否有环
public static <T>  MySingleList<T>.Node<T> isRing(MySingleList<T>.Node<T> head){
    if(head == null)      
      return null;
    }
    //定义快慢指针
    MySingleList<T>.Node<T> slow = head.getNext();
    //链表中只有一个节点
    if(slow == null){
        return null;
    }
    MySingleList<T>.Node<T> fast = slow.getNext();

    while(fast != null && fast.getNext() != null && slow != null){
        //快指针和慢指针指向相同的节点(相遇)
        if(slow == fast){
            return slow;
        }
        //快指针走两步，慢指针走一步
        slow = slow.getNext();
        fast = fast.getNext().getNext();
    }
    return null;
}
//求环的入口节点
public static <T> MySingleList<T>.Node<T> entranceNode(MySingleList<T>.Node<T> head){
    MySingleList<T>.Node<T> meetingNode = isRing(head); //meetingNode存在于环中
    //计算环中节点的个数
    int length = 1;
    MySingleList<T>.Node<T> tmp = meetingNode;
    while(tmp.getNext() != meetingNode){
        tmp = tmp.getNext();
        length++;
    }
    //类比求倒数第k个节点的算法
    //front先走length  front, behind开始同时走  front != behind
    MySingleList<T>.Node<T> front = head;
    MySingleList<T>.Node<T> behind = head;
    for(int i=0; i<length ;i++){
        front = front.getNext();
    }
    //front和behind同时走
    while(front != behind){
        front = front.getNext();
        behind = behind.getNext();
    }
    return front;
}