左神算法第三节课：（栈,矩阵,链表）用数组实现栈与队列，栈中最小元素，转圈打印矩阵，旋转方阵，之字打印矩阵，有序矩阵中找数，反转链表，打印有序链表公共部分，回文链表等

左神算法第三节课

目录：

• 用数组实现栈与队列（先进先出），
• 栈中最小元素，
• 矩阵
  • 转圈打印矩阵，
  • 旋转方阵，
  • 之字打印矩阵，
  • 有序矩阵中找数，
• 链表
  • 反转链表，
  • 打印有序链表公共部分，
  • 回文链表
• 等

---

1、用数组实现栈和队列

1.1【实现栈（先进后出）】用数组结构实现大小固定的队列和栈，如图所示：

Size：表示下一个数要放的下标。

/*
 * 固定数组实现栈
 */
public class ArrayStack {

    private Integer[] arr;
    private Integer size;//指向下一个对象被存放的下标
    
    public ArrayStack(int intiSize) {
        if (intiSize<0) {
            throw new IllegalArgumentException("The init size is less 0");
        }
        size = 0;
        arr = new Integer[intiSize];
    }
    
    public Integer peek() {
        if (size <= 0) {
            throw new IllegalArgumentException("The stack is null");
        }
        return arr[size-1];        
    }
    
    public void push(Integer i) {
        if (size >= arr.length) {
            throw new IllegalArgumentException("The stack is full");
        }
        arr[size++] = i;        
    }
    
    public Integer pop() {
        if (size <= 0) {
            throw new IllegalArgumentException("The stack is empty");
        }
        return arr[--size];        
    }
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
    }
}

1.2【实现队列（先进先出）】

end：新加一个数的位置；start：拿出一个数的位置；size：数组里的数的个数，把start和end的关系解耦掉；如果不加size，则会使得start和end之间需要抠边界，会产生start追击end，关系不容易明确。如图所示：

/*
 * 固定数组实现队列
 */
public class ArrayQueue {

    private Integer[] arr;
    private Integer size;//指向下一个对象被存放的下标
    private Integer start;
    private Integer end;
    public ArrayQueue(int intiSize) {
        if (intiSize<0) {
            throw new IllegalArgumentException("The init size is less 0");
        }
        size = 0;
        arr = new Integer[intiSize];
        start = 0;
        end = 0;
    }    
    public Integer peek() {
        if (size <= 0) {
            throw new IllegalArgumentException("The stack is null");
        }
        return arr[start];        
    }    
    public void push(Integer i) {
        if (size >= arr.length) {
            throw new IllegalArgumentException("The stack is full");
        }
        size++;
        arr[end] = i;    
        end = end == arr.length-1 ? 0 : end+1;
    }    
    public Integer poll() {
        if (size <= 0) {
            throw new IllegalArgumentException("The stack is empty");
        }
        size--;
        int temp = start;
        start = start == arr.length-1 ? 0 : start+1; 
        return arr[temp];        
    }
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
    }
}

2、栈中最小元素

实现一个特殊栈，在实现栈的基础功能上，再实现返回当前栈中最小元素的操作。

要求：

1. Pop, push, getMin操作的时间复杂度都是O(1)；
2. 设计的栈类型可以使用现成的栈结构；

题目解析：

当前栈中最小元素的意思就是，在任何一步，都可以获得当前栈中所有元素的最小值。又因为可以使用现成的栈结构，故可以通过维护两个栈来实现。

设计思路：

设计一个data栈，存放的是数据，

再设计一个栈存放的是当前数组中最小的值。

即当data第一个压入5时，min也压入5，当data压入10时，10 与min栈顶数据元素5相比，10>5,故min继续压入5；data再压入2时,2与min栈顶相比,2<5,故min压入2…依次往复。然后取的时候，data弹出一个元素，min栈也跟着弹出一个元素。

实现：

package class_03;
import java.util.Stack;

public class Code_02_GetMinStack {
    public static class MyStack1 {
        private Stack<Integer> stackData;
        private Stack<Integer> stackMin;

        public MyStack1() {
            this.stackData = new Stack<Integer>();
            this.stackMin = new Stack<Integer>();
        }

        public void push(int newNum) {
            if (this.stackMin.isEmpty()) {
                this.stackMin.push(newNum);
            } else if (newNum <= this.getmin()) {
                this.stackMin.push(newNum);
            }
            this.stackData.push(newNum);
        }

        public int pop() {
            if (this.stackData.isEmpty()) {
                throw new RuntimeException("Your stack is empty.");
            }
            int value = this.stackData.pop();
            if (value == this.getmin()) {
                this.stackMin.pop();
            }
            return value;
        }

        public int getmin() {
            if (this.stackMin.isEmpty()) {
                throw new RuntimeException("Your stack is empty.");
            }
            return this.stackMin.peek();
        }
    }

    public static class MyStack2 {
        private Stack<Integer> stackData;
        private Stack<Integer> stackMin;

        public MyStack2() {
            this.stackData = new Stack<Integer>();
            this.stackMin = new Stack<Integer>();
        }

        public void push(int newNum) {
            if (this.stackMin.isEmpty()) {
                this.stackMin.push(newNum);
            } else if (newNum < this.getmin()) {
                this.stackMin.push(newNum);
            } else {
                int newMin = this.stackMin.peek();
                this.stackMin.push(newMin);
            }
            this.stackData.push(newNum);
        }

        public int pop() {
            if (this.stackData.isEmpty()) {
                throw new RuntimeException("Your stack is empty.");
            }
            this.stackMin.pop();
            return this.stackData.pop();
        }

        public int getmin() {
            if (this.stackMin.isEmpty()) {
                throw new RuntimeException("Your stack is empty.");
            }
            return this.stackMin.peek();
        }
    }

    public static void main(String[] args) {
        MyStack1 stack1 = new MyStack1();
        stack1.push(3);
        System.out.println(stack1.getmin());
        stack1.push(4);
        System.out.println(stack1.getmin());
        stack1.push(1);
        System.out.println(stack1.getmin());
        System.out.println(stack1.pop());
        System.out.println(stack1.getmin());

        System.out.println("=============");

        MyStack1 stack2 = new MyStack1();
        stack2.push(3);
        System.out.println(stack2.getmin());
        stack2.push(4);
        System.out.println(stack2.getmin());
        stack2.push(1);
        System.out.println(stack2.getmin());
        System.out.println(stack2.pop());
        System.out.println(stack2.getmin());
    }

}

输出：

3
3
1
1
3
=============
3
3
1
1
3

3、队列，栈结构互相实现

3.1 如何仅用队列结构实现栈结构？

栈结构（先进后出），队列结构（先进先出），故需要两个队列，来回倒腾，留下最后一个数据返回即可。

3.2 如何仅用栈结构实现队列结构？

需要两个栈，来回倒腾，弹出pop栈中的栈顶即可。

需要注意的是：这里不用交换引用。数据进栈一直进的是push栈，出栈一直是从push栈中弹出全部，然后将pop栈顶返回。

package class_03;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class Code_03_StackAndQueueConvert {

    public static class TwoStacksQueue {
        private Stack<Integer> stackPush;
        private Stack<Integer> stackPop;
        public TwoStacksQueue() {
            stackPush = new Stack<Integer>();
            stackPop = new Stack<Integer>();
        }
        public void push(int pushInt) {
            stackPush.push(pushInt);
        }
        public int poll() {
            if (stackPop.empty() && stackPush.empty()) {
                throw new RuntimeException("Queue is empty!");
            } else if (stackPop.empty()) {//满足第二个要求,pop中没数据才能倒；
                while (!stackPush.empty()) {//满足第一个要求,倒就倒完;
                    stackPop.push(stackPush.pop());
                }
            }
            return stackPop.pop();
        }
        public int peek() {
            if (stackPop.empty() && stackPush.empty()) {
                throw new RuntimeException("Queue is empty!");
            } else if (stackPop.empty()) {
                while (!stackPush.empty()) {
                    stackPop.push(stackPush.pop());
                }
            }
            return stackPop.peek();
        }
    }

    public static class TwoQueuesStack {
        private Queue<Integer> queue;
        private Queue<Integer> help;
        public TwoQueuesStack() {
            queue = new LinkedList<Integer>();
            help = new LinkedList<Integer>();
        }
        public void push(int pushInt) {
            queue.add(pushInt);
        }
        public int peek() {
            if (queue.isEmpty()) {
                throw new RuntimeException("Stack is empty!");
            }
            //留下最后一个元素留作返回，其他的倒腾到help队列中；
            while (queue.size() != 1) {
                help.add(queue.poll());
            }
            int res = queue.poll();
            help.add(res);//因为peek()返回的是栈顶元素并且不删除，故还要加入到help队列中；
            swap();//交换引用
            return res;
        }
        public int pop() {
            if (queue.isEmpty()) {
                throw new RuntimeException("Stack is empty!");
            }
            while (queue.size() > 1) {
                help.add(queue.poll());
            }
            //因为pop()返回的是栈顶元素并且删除，故不用加入到help队列中；
            int res = queue.poll();
            swap();
            return res;
        }
        private void swap() {
            Queue<Integer> tmp = help;
            help = queue;
            queue = tmp;
        }
    }

}

4、矩阵相关问题

4.1 转圈（螺旋）打印矩阵

给定一个整型矩阵matrix，请按照转圈的方式打印它。

例如： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

打印结果为：1，2，3，4，8，12，16，15，14，13，9，5，6，7，11， 10

【要求】 额外空间复杂度为O(1)。

              

                    

package class_03;

import java.util.ArrayList;

/*
 * 螺旋打印矩阵；
 */
public class Code_06_PrintMatrixSpiralOrder {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        return null;
        
    }
    /*  tC      dC
      tR 1 2 3 4 5 
         2 3 4 5 6
         3 4 5 6 7
      dR 4 5 6 7 8 
     */
    public static void spiralOrderPrint(int[][] matrix) {
        //左上角点坐标(tR,tC)，右下角点坐标(dR,dC);
        int tR = 0;
        int tC = 0;
        int dR = matrix.length-1;
        int dC = matrix[0].length-1;
        while (tR<=dR && tC<=dC) {
            printEdge(matrix,tR++,tC++,dC--,dR--);
        }
        
    }
    private static void printEdge(int[][] matrix, int tR, int tC, int dR, int dC) {
        //判断螺旋是否到达最后一次，即要么纵坐标相等，要么横坐标相等;
        if (tR == dR) {
            for (int i = tC; i <= dC; i++) {
                System.out.println(matrix[tR][i]+" ");
            }
        }else if (tC == dC) {
            for (int i = tR; i <= dR; i++) {
                System.out.println(matrix[i][tC]+" ");
            }
        }else {
            //如果不是最后一次螺旋
            /*  tC      dC
              tR 1 2 3 4 5 
                 2 3 4 5 6
                 3 4 5 6 7
              dR 4 5 6 7 8 
             */
            //从左往右
            for (int i = tC; i < dC; i++) {
                System.out.print(matrix[tR][i]+" + ");
            }
            //从上往下
            for (int i = tR; i < dR; i++) {
                System.out.print(matrix[i][dC]+" - ");                
            }
            //从右往左
            for (int i = dC; i > tC; i--) {
                System.out.print(matrix[dR][i]+" * ");
            }
            //从上往下
            for (int i = dR; i > tR; i--) {
                System.out.print(matrix[i][tC]+" / ");                
            }
            
        }
        
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[][] matrix = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 },
                { 13, 14, 15, 16 } };
        spiralOrderPrint(matrix);
    }

}

输出：

1 + 2 + 3 + 4 - 8 - 12 - 16 * 15 * 14 * 13 / 9 / 5 / 6 + 7 - 11 * 10 / 

4.2 旋转正方形矩阵

给定一个整型正方形矩阵matrix，请把该矩阵调整成顺时针旋转90度的样子。

【要求】 额外空间复杂度为O(1)。

                   

 同样的思想：记录左上角坐标（tR,tC）和右下角坐标（dR,dC）。旋转每一行/列即可。

package class_03;

public class Code_05_RotateMatrix {

    public static void rotate(int[][] matrix) {
        int tR = 0;
        int tC = 0;
        int dR = matrix.length - 1;
        int dC = matrix[0].length - 1;
        while (tR < dR) {
            rotateEdge(matrix, tR++, tC++, dR--, dC--);
        }
    }

    public static void rotateEdge(int[][] m, int tR, int tC, int dR, int dC) {
        //记录每一行/列的元素个数;
        int times = dC - tC; 
        int tmp = 0;
        //旋转
        for (int i = 0; i != times; i++) {
            tmp = m[tR][tC + i];
            m[tR][tC + i] = m[dR - i][tC];
            m[dR - i][tC] = m[dR][dC - i];
            m[dR][dC - i] = m[tR + i][dC];
            m[tR + i][dC] = tmp;
        }
    }

    public static void printMatrix(int[][] matrix) {
        for (int i = 0; i != matrix.length; i++) {
            for (int j = 0; j != matrix[0].length; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        int[][] matrix = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 },
                { 13, 14, 15, 16 } };
        printMatrix(matrix);
        rotate(matrix);
        System.out.println("=========");
        printMatrix(matrix);
    }
}

输出：

1 2 3 4 
5 6 7 8 
9 10 11 12 
13 14 15 16 
=========
13 9 5 1 
14 10 6 2 
15 11 7 3 
16 12 8 4 

4.3 “之”字形打印矩阵

给定一个矩阵matrix，按照“之”字形的方式打印这个矩阵，例如： 1 2 3 4 5 6 7 8 9 10 11 12，“之”字形打印的结果为：1，2，5，9，6，3，4，7，10，11，8，12

【要求】 额外空间复杂度为O(1)。

                 

分析：给定一个函数，实现从沿对角线打印的功能。参数为对角线上两个点以及一个判断是从上往下，还是从下往上的布尔类型变量。注意：三木运算时，要注意顺序，先判断与条件无关的行/列，如果将36/37,38/39互相调换位置，则出错。

实现：

package class_03;

import java.util.ArrayList;

/*
 * 之字型打印矩阵。
 * 给定一个矩阵matrix，按照“之”字形的方式打印这
 * 个矩阵，例如： 1 2 3 4 5 6 7 8 9 10 11 12
 * “之”字形打印的结果为：1，2，5，9，6，3，4，7，10，11，8，12；
 * 要求：额外空间复杂度为O(1)
 * 
 * 给定一个函数，实现从沿对角线打印的功能。参数为对角线上两个点以及一个判断是从上往下，还是从下往上的布尔类型变量。
 * 
 * 注意：三木运算时，要注意顺序，先判断与条件无关的行/列，如果将36/37,38/39互相调换位置，则出错。
 */
public class Code_08_ZigZagPrintMatrix {

    /*条件结束为，a点来到最后一行，b点来到最后一列;
     *         aC  
         1  2  3  4 aR
         5  6  7  8 
      bR 9  10 11 12
        bC        
     */
    public static void printZigZag(int[][] matrix) {
        //左下角点坐标(bR,bC)，右上角点坐标(aR,aC);
        int aR = 0;
        int aC = 0;
        int bR = 0;
        int bC = 0;
        int endR = matrix.length-1;
        int endC = matrix[0].length-1;
        boolean fromUp = false;//用来判断是从左下到右上，还是从右上到左下。
        while (aR < endR+1) {//||bC != endC+1
            printLevel(matrix,aR,aC,bR,bC,fromUp);
            aR = aC == endC ? ++aR : aR;
            aC = aC == endC ? aC : ++aC;
            bC = bR == endR ? ++bC : bC;
            bR = bR == endR ? bR : ++bR;
            
            fromUp=!fromUp;
        }
        
        
    }
    
    private static void printLevel(int[][] matrix, int aR, int aC, int bR, int bC, boolean fromUp) {
        /*条件结束为，a点来到最后一行，b点来到最后一列;
         *         aC  
             1  2  3  4 aR
             5  6  7  8 
          bR 9  10 11 12
            bC        
         */
        if (fromUp) {
            while (bC <= aC) {
                System.out.print(matrix[aR++][aC--]+" ");
            }
        }else {
            while (bC <= aC) {
                System.out.print(matrix[bR--][bC++]+" ");
            }
        }
        
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[][] matrix = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 }};
        printMatrix(matrix);
        System.out.println("-----------");
        printZigZag(matrix);

//        printMatrix(matrix);
    }
    private static void printMatrix(int[][] matrix) {
        // TODO Auto-generated method stub
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                System.out.print(matrix[i][j]+"	");
            }
            System.out.println();
        }
    }

}
package class_03;

import java.util.ArrayList;

/*
 * 之字型打印矩阵。
 * 给定一个矩阵matrix，按照“之”字形的方式打印这
 * 个矩阵，例如： 1 2 3 4 5 6 7 8 9 10 11 12
 * “之”字形打印的结果为：1，2，5，9，6，3，4，7，10，11，8，12；
 * 要求：额外空间复杂度为O(1)
 * 
 * 给定一个函数，实现从沿对角线打印的功能。参数为对角线上两个点以及一个判断是从上往下，还是从下往上的布尔类型变量。
 * 
 * 注意：三木运算时，要注意顺序，先判断与条件无关的行/列，如果将36/37,38/39互相调换位置，则出错。
 */
public class Code_08_ZigZagPrintMatrix {

    /*条件结束为，a点来到最后一行，b点来到最后一列;
     *         aC  
         1  2  3  4 aR
         5  6  7  8 
      bR 9  10 11 12
        bC        
     */
    public static void printZigZag(int[][] matrix) {
        //左下角点坐标(bR,bC)，右上角点坐标(aR,aC);
        int aR = 0;
        int aC = 0;
        int bR = 0;
        int bC = 0;
        int endR = matrix.length-1;
        int endC = matrix[0].length-1;
        boolean fromUp = false;//用来判断是从左下到右上，还是从右上到左下。
        while (aR < endR+1) {//||bC != endC+1
            printLevel(matrix,aR,aC,bR,bC,fromUp);
            aR = aC == endC ? ++aR : aR;
            aC = aC == endC ? aC : ++aC;
            bC = bR == endR ? ++bC : bC;
            bR = bR == endR ? bR : ++bR;
            
            fromUp=!fromUp;
        }
        
        
    }
    
    private static void printLevel(int[][] matrix, int aR, int aC, int bR, int bC, boolean fromUp) {
        /*条件结束为，a点来到最后一行，b点来到最后一列;
         *         aC  
             1  2  3  4 aR
             5  6  7  8 
          bR 9  10 11 12
            bC        
         */
        if (fromUp) {
            while (bC <= aC) {
                System.out.print(matrix[aR++][aC--]+" ");
            }
        }else {
            while (bC <= aC) {
                System.out.print(matrix[bR--][bC++]+" ");
            }
        }
        
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[][] matrix = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 }};
        printMatrix(matrix);
        System.out.println("-----------");
        printZigZag(matrix);

//        printMatrix(matrix);
    }
    private static void printMatrix(int[][] matrix) {
        // TODO Auto-generated method stub
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                System.out.print(matrix[i][j]+"	");
            }
            System.out.println();
        }
    }

}

输出：

1    2    3    4    
5    6    7    8    
9    10    11    12    
-----------
1 2 5 9 6 3 4 7 10 11 8 12 

4.4 在行列都排好序的矩阵中找数

 给定一个有N*M的整型矩阵matrix和一个整数K，matrix的每一行和每一 列都是排好序的。实现一个函数，判断K是否在matrix中。 例如： 0 1 2 5 2 3 4 7 4 4 4 8 5 7 7 9 如果K为7，返回true；如果K为6，返回false。

【要求】 时间复杂度为O(N+M)，额外空间复杂度为O(1)。

                       

 思路：

从右上角开始往左下角遍历，为什么呢？

因为每一行，每一列都是有序的，且是升序，从右上角开始往左下角遍历的话，如果当前值大于目标值，就列数减一，如果当前值小于目标值的话，就行数加一。直至找到目标值。

实现：

package class_03;
/*
 * 在行列都排好序的矩阵中找数
【题目】 给定一个有N*M的整型矩阵matrix和一个整数K，
matrix的每一行和每一 列都是排好序的。实现一个函数，判断K
是否在matrix中。 例如： 0 1 2 5 2 3 4 7 4
4 4 8 5 7 7 9 如果K为7，返回true；如果K为6，返
回false。
【要求】 时间复杂度为O(N+M)，额外空间复杂度为O(1)。
 */
public class Code_09_FindNumInSortedMatrix {

    public static boolean isContains(int[][] matrix, int K) {
        int row = 0;
        int col = matrix[0].length -1;
        while (row < matrix.length && col > -1) {
            if (matrix[row][col] == K) {
                return true;
            }else if (matrix[row][col] > K) {
                --col;
            }else {
                ++row;
            }
        }        
        return false;        
    }
    
    public static void test() {
        int[][] matrix = new int[][] { { 0, 1, 2, 3, 4, 5, 6 },// 0
            { 10, 12, 13, 15, 16, 17, 18 },// 1
            { 23, 24, 25, 26, 27, 28, 29 },// 2
            { 44, 45, 46, 47, 48, 49, 50 },// 3
            { 65, 66, 67, 68, 69, 70, 71 },// 4
            { 96, 97, 98, 99, 100, 111, 122 },// 5
            { 166, 176, 186, 187, 190, 195, 200 },// 6
            { 233, 243, 321, 341, 356, 370, 380 } // 7
        };
        int K = 233;
        System.out.println(isContains(matrix, K));
    }
    public static void main(String[] args) {
        test();
        
    }

}

输出：

true

5、链表相关问题

 反转链表：

分别实现反转单向链表和反转双向链表的函数。

【要求】 如果链表长度为N，时间复杂度要求为O(N)，额外空间复杂度要求为O(1)。

5.1 单向链表反转

package class_03;

public class Code_07_ReverseList {

    public static class Node {
        public int value;
        public Node next;

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

    public static Node reverseList(Node head) {
        Node pre = null;
        Node next = null;
        while (head != null) {
            next = head.next;
            head.next = pre;
            pre = head;
            head = next;
        }
        return pre;
    }

    public static class DoubleNode {
        public int value;
        public DoubleNode last;
        public DoubleNode next;

        public DoubleNode(int data) {
            this.value = data;
        }
    }

    public static DoubleNode reverseList(DoubleNode head) {
        DoubleNode pre = null;
        DoubleNode next = null;
        while (head != null) {
            next = head.next;
            head.next = pre;
            head.last = next;
            pre = head;
            head = next;
        }
        return pre;
    }

    public static void printLinkedList(Node head) {
        System.out.print("Linked List: ");
        while (head != null) {
            System.out.print(head.value + " ");
            head = head.next;
        }
        System.out.println();
    }

    public static void printDoubleLinkedList(DoubleNode head) {
        System.out.print("Double Linked List: ");
        DoubleNode end = null;
        while (head != null) {
            System.out.print(head.value + " ");
            end = head;
            head = head.next;
        }
        System.out.print("| ");
        while (end != null) {
            System.out.print(end.value + " ");
            end = end.last;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Node head1 = new Node(1);
        head1.next = new Node(2);
        head1.next.next = new Node(3);
        printLinkedList(head1);
        head1 = reverseList(head1);
        printLinkedList(head1);

        DoubleNode head2 = new DoubleNode(1);
        head2.next = new DoubleNode(2);
        head2.next.last = head2;
        head2.next.next = new DoubleNode(3);
        head2.next.next.last = head2.next;
        head2.next.next.next = new DoubleNode(4);
        head2.next.next.next.last = head2.next.next;
        printDoubleLinkedList(head2);
        printDoubleLinkedList(reverseList(head2));

    }

}

输出：

Linked List: 1 2 3 
Linked List: 3 2 1 
Double Linked List: 1 2 3 4 | 4 3 2 1 
Double Linked List: 4 3 2 1 | 1 2 3 4 

5.2 打印两个有序链表的公共部分

 给定两个有序链表的头指针head1和head2，打印两个链表的公共部分。

思路：同归并排序，merge过程，比较大小，在这里比较是否相同即可。

package class_03;

public class Code_10_PrintCommonPart {

    public static class Node {
        public int value;
        public Node next;
        public Node(int data) {
            this.value = data;
        }
    }

    public static void printCommonPart(Node head1, Node head2) {
        System.out.print("Common Part: ");
        while (head1 != null && head2 != null) {
            if (head1.value < head2.value) {
                head1 = head1.next;
            } else if (head1.value > head2.value) {
                head2 = head2.next;
            } else {
                System.out.print(head1.value + " ");
                head1 = head1.next;
                head2 = head2.next;
            }
        }
        System.out.println();
    }

    public static void printLinkedList(Node node) {
        System.out.print("Linked List: ");
        while (node != null) {
            System.out.print(node.value + " ");
            node = node.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Node node1 = new Node(2);
        node1.next = new Node(3);
        node1.next.next = new Node(5);
        node1.next.next.next = new Node(6);

        Node node2 = new Node(1);
        node2.next = new Node(2);
        node2.next.next = new Node(5);
        node2.next.next.next = new Node(7);
        node2.next.next.next.next = new Node(8);

        printLinkedList(node1);
        printLinkedList(node2);
        printCommonPart(node1, node2);

    }

}

输出：

Linked List: 2 3 5 6 
Linked List: 1 2 5 7 8 
Common Part: 2 5 

5.3 判断一个链表是否为回文结构

 给定一个链表的头节点head，请判断该链表是否为回文结构。 

例如：

 1->2->1，返回true。 

1->2->2->1，返回true。

15->6->15，返回true。

 1->2->3，返回false。

进阶： 如果链表长度为N，时间复杂度达到O(N)，额外空间复杂度达到O(1)。

方法一：放到栈里面再逆序比对（利用额外空间）

方法二：两个指针，1走一步，2走两步，2到了终点，1就到了中点，然后1往后的压栈，在逐一比对。

方法三：（额外空间O(1)）：先通过快慢指针，找到中点，然后改变中间后面的链表的指向，再从两端逐一比对，最后再把指针还原如初。

              

 实现：

package class_03;

import java.util.Stack;

/*
 * 判断一个链表是否为回文结构
 * 【题目】 给定一个链表的头节点head，请判断该链表是否为回文结构。
 *  例如： 1->2->1，返回true。 1->2->2->1，返回true。
 *  15->6->15，返回true。 1->2->3，返回false。
 *  进阶： 如果链表长度为N，时间复杂度达到O(N)，额外空间复杂度达到O(1)。
 */
public class Code_11_IsPalindromeList {

    public static class Node {
        public int value;
        public Node next;

        public Node(int data) {
            this.value = data;
        }
    }
    
    //need n extra space
    public static boolean isPalindrome1(Node head) {
        Stack<Node> stack = new Stack<>();
        Node node = head;
        while (node!=null) {
            stack.push(node);
            node = node.next;
        }
        while (head!=null) {
            if (head.value != stack.pop().value) {
                return false;
            }
            head = head.next;
        }        
        return true;        
    }
    
    //need n/2 extra space
        public static boolean isPalindrome2(Node head) {
            if (head == null || head.next == null) {
                return true;
            }
            Stack<Node> stack = new Stack<>();
            Node slow  = head;
            Node quick = head.next;
            //quick->tail,slow->middle;
            while (quick.next!= null && quick.next.next!=null) {
                quick = quick.next.next;
                slow = slow.next;
            }
            slow = slow.next;
            while (slow!=null) {
                stack.push(slow);
                slow = slow.next;
            }
            while (!stack.isEmpty()) {
                if (stack.pop().value != head.value) {
                    return false;
                }
                head = head.next;
            }    
            return true;        
        }
    
        //need O(1) extra space;
        public static boolean isPalindrome3(Node head) {
            if (head == null || head.next == null) {
                return true;
            }
            boolean result = true;
            Node slow  = head;
            Node quick = head;
            //quick->tail,slow->middle;
            //注意的是，在判断quick.next.next!=null之前，
            //得先要判断quick.next!=null。
            while (quick.next!=null && quick.next.next!=null) {
                quick = quick.next.next;
                slow = slow.next;
            }
            //反转后半段的指针；
            Node cur = null;
            quick = slow.next;
            slow.next = null;
            while (quick!=null) {
                cur = quick.next;
                quick.next = slow;
                slow = quick;
                quick = cur;            
            }
            cur = slow;//最后节点
            quick = head;//左边第一个节点
            while (slow != null && quick != null) {
                if (slow.value != quick.value) {
                    result = false;
                    break;
                }
                slow = slow.next;
                quick = quick.next;
            }
            //反转指针
            slow = cur.next;//倒数第二个
            cur.next = null;
            while (slow!=null) {
                quick = slow.next;
                slow.next = cur;
                cur = slow;
                slow = quick;
            }

            return result;            
        }
        
    public static void printLinkedList(Node node) {
        System.out.print("Linked List: ");
        while (node != null) {
            System.out.print(node.value + " ");
            node = node.next;
        }
        System.out.println();
    }
    
    public static void test() {
        Node head = null;        
        head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        printLinkedList(head);
        System.out.print(isPalindrome1(head) + " | ");
        System.out.print(isPalindrome2(head) + " | ");
        System.out.println(isPalindrome3(head) + " | ");
        printLinkedList(head);
        System.out.println("=========================");
        
        head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(1);
        printLinkedList(head);
        System.out.print(isPalindrome1(head) + " | ");
        System.out.print(isPalindrome2(head) + " | ");
        System.out.println(isPalindrome3(head) + " | ");
        printLinkedList(head);
        System.out.println("=========================");
        
        head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(1);
        printLinkedList(head);
        System.out.print(isPalindrome1(head) + " | ");
        System.out.print(isPalindrome2(head) + " | ");
        System.out.println(isPalindrome3(head) + " | ");
        printLinkedList(head);
        System.out.println("=========================");
        
        head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(2);
        head.next.next.next = new Node(1);
        printLinkedList(head);
        System.out.print(isPalindrome1(head) + " | ");
        System.out.print(isPalindrome2(head) + " | ");
        System.out.println(isPalindrome3(head) + " | ");
        printLinkedList(head);
        System.out.println("=========================");
        
        head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(2);
        head.next.next.next.next = new Node(1);
        printLinkedList(head);
        System.out.print(isPalindrome1(head) + " | ");
        System.out.print(isPalindrome2(head) + " | ");
        System.out.println(isPalindrome3(head) + " | ");
        printLinkedList(head);
        System.out.println("=========================");
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        test();
    }

}

输出：

Linked List: 1 2 3 
false | false | false | 
Linked List: 1 2 3 
=========================
Linked List: 1 2 1 
true | true | true | 
Linked List: 1 2 1 
=========================
Linked List: 1 2 3 1 
false | false | false | 
Linked List: 1 2 3 1 
=========================
Linked List: 1 2 2 1 
true | true | true | 
Linked List: 1 2 2 1 
=========================
Linked List: 1 2 3 2 1 
true | true | true | 
Linked List: 1 2 3 2 1 
=========================

5.4 将单向链表按某值划分成左边小、中间相等、右边大的形式

 给定一个单向链表的头节点head，节点的值类型是整型，再给定一个整 数pivot。实现一个调整链表的函数，将链表调整为左部分都是值小于 pivot 的节点，中间部分都是值等于pivot的节点，右部分都是值大于 pivot的节点。除这个要求外，对调整后的节点顺序没有更多的要求。 例如：链表9->0->4->5->1，pivot=3。 调整后链表可以是1->0->4->9->5，也可以是0->1->9->5->4。总之，满 足左部分都是小于3的节点，中间部分都是等于3的节点（本例中这个部分为空），右部分都是大于3的节点即可。对某部分内部的节点顺序不做 要求。

可以使用荷兰国旗的方法去处理，数组每个元素变为结点类型，然后再接起来。

进阶： 在原问题的要求之上再增加如下两个要求。

在左、中、右三个部分的内部也做顺序要求，要求每部分里的节点从左 到右的顺序与原链表中节点的先后次序一致。 例如：链表9->0->4->5->1，pivot=3。调整后的链表是0->1->9->4->5。 在满足原问题要求的同时，左部分节点从左到右为0、1。在原链表中也 是先出现0，后出现1；中间部分在本例中为空，不再讨论；右部分节点 从左到右为9、4、5。在原链表中也是先出现9，然后出现4，最后出现5。

如果链表长度为N，时间复杂度请达到O(N)，额外空间复杂度请达到O(1)。

准备三个变量，这三个变量都是节点对象的引用类型。less eq more

思路：

先遍历链表，找到第一个小于/等于/大于num的节点，让less/eq /more 等于那个节点。然后每组都再准备一个end，每次加入一个，end就加一，直到最后把三个小链表头尾链接起来。（原理是把一个大链表，拆成三个小链表，再组装起来）有限几个变量O(1)。

所以一共是3组，6个变量，less/end, eq/end, more/end,

实现：

package class_03;

import java.util.Stack;

/*
 * 将单向链表按某值划分成左边小、中间相等、右边大的形式
【题目】 给定一个单向链表的头节点head，节点的值类型是整型，再给定一个
整 数pivot。实现一个调整链表的函数，将链表调整为左部分都是值小于 pivot
的节点，中间部分都是值等于pivot的节点，右部分都是值大于 pivot的节点。
除这个要求外，对调整后的节点顺序没有更多的要求。 例如：链表9->0->4->5-
>1，pivot=3。 调整后链表可以是1->0->4->9->5，也可以是0->1->9->5->4。总
之，满 足左部分都是小于3的节点，中间部分都是等于3的节点（本例中这个部
分为空），右部分都是大于3的节点即可。对某部分内部的节点顺序不做 要求。

进阶： 在原问题的要求之上再增加如下两个要求。
在左、中、右三个部分的内部也做顺序要求，要求每部分里的节点从左 到右的
顺序与原链表中节点的先后次序一致。 例如：链表9->0->4->5->1，pivot=3。
调整后的链表是0->1->9->4->5。 在满足原问题要求的同时，左部分节点从左到
右为0、1。在原链表中也 是先出现0，后出现1；中间部分在本例中为空，不再
讨论；右部分节点 从左到右为9、4、5。在原链表中也是先出现9，然后出现4，
最后出现5。
如果链表长度为N，时间复杂度请达到O(N)，额外空间复杂度请达到O(1)。
 */
public class Code_12_SmallerEqualBigger {

    public static class Node {
        public int value;
        public Node next;

        public Node(int data) {
            this.value = data;
        }
    }
    
    public static Node listPartition1(Node head, int pivot) {
        if (head == null) {
            return null;
        }
        Node cur = head ;
        int i = 0;
        //遍历链表至结尾;
        while (cur != null) {
            ++i;
            cur  = cur.next;
        }
        Node[] nodes = new Node[i];
        i=0;
        cur = head;
        //将链表每个节点都放入节点数组；
        for (int j = 0; j < nodes.length; j++) {
            nodes[j] = cur ;
            cur = cur.next;
        }
        arrPartion(nodes,pivot);//比大小操作；
        //再将数组里的节点再连接形成链表；
        for (int j = 1; j < nodes.length; j++) {
            nodes[j-1].next = nodes[j];
        }
        return nodes[0];        
    }
    
    private static void arrPartion(Node[] nodes, int pivot) {
        //运用荷兰国旗思维
        int small = -1;
        int big = nodes.length;
        int index = 0;
        while (index != big) {
            if (nodes[index].value < pivot) {
                swap(nodes,++small,index++);
            }else if (nodes[index].value == pivot) {
                index++;            
            }else {
                swap(nodes,--big,index);
            }
        }
    }

    private static void swap(Node[] nodes, int i, int j) {
//        Node temp = nodes[i];
        int temp = nodes[i].value;
        nodes[i].value = nodes[j].value;
        nodes[j].value = temp;
    }
    
    public static void printLinkedList(Node node) {
        System.out.print("Linked List: ");
        while (node != null) {
            System.out.print(node.value + " ");
            node = node.next;
        }
        System.out.println();
    }
    
    
    public static Node listPartition2(Node head, int pivot) {
        //分成3组，六个变量；
        Node sHead = null;
        Node sTail = null;
        Node eHead = null;
        Node eTail = null;
        Node bHead = null;
        Node bTail = null;
        Node cur = head;
        Node next = null;
        // every node distributed to three lists
        while (cur != null) {
            //把当前节点的next都置为null;即相当于把每个节点都单独出来；
            next = cur.next;
            cur.next = null;
            //开始判断每一个节点;
            if (cur.value < pivot) {
                if (sHead == null) {
                    sHead = cur;
                    sTail = cur;
                }else {
                    sTail.next = cur;
                    sTail = cur;
                }
            }else if (cur.value == pivot) {
                if (eHead == null) {
                    eHead = cur;
                    eTail = cur;
                }else {
                    eTail.next = cur;
                    eTail = cur;
                }
            }else {                
                if (bHead == null) {
                    bHead = cur;
                    bTail = cur;
                }else {
                    bTail.next = cur;
                    bTail = cur;
                }                
            }
            cur = next;
        }
        //链接起来三个链表;需要注意的是看每个链表是否为空;
        if (sTail!=null) {
            sTail.next = eHead;
            eTail = eTail == null ? sTail : eTail;
        }
        if (eTail != null) {
            eTail.next = bHead;
        }
        return sHead != null ? sHead : (eHead != null ? eHead : bHead);        
    }
    public static void test() {
        Node head1 = new Node(7);
        head1.next = new Node(9);
        head1.next.next = new Node(1);
        head1.next.next.next = new Node(8);
        head1.next.next.next.next = new Node(5);
        head1.next.next.next.next.next = new Node(2);
        head1.next.next.next.next.next.next = new Node(5);
        printLinkedList(head1);
//         head1 = listPartition1(head1, 4);
        head1 = listPartition2(head1, 5);
        printLinkedList(head1);
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        test();
    }

}

输出：

Linked List: 7 9 1 8 5 2 5 
Linked List: 1 2 5 5 7 9 8 

5.5 复制含有随机指针节点的链表

一种特殊的链表节点类描述如下：

Node类中的value是节点值，next指针和正常单链表中next指针的意义一样，都指向下一个节点，rand指针是Node类中新增的指针，这个指针可 能指向链表中的任意一个节点，也可能指向null。 给定一个由Node节点类型组成的无环单链表的头节点head，请实现一个函数完成这个链表中所有结构的复制，并返回复制的新链表的头节点。

方法一：准备一个hashmap<Node,Node>，依次把结点作为key，并以key结点的值new一个新节点作为value存入。然后再通过key查找value的方式，复制指针的指向，达到深入拷贝。

思路：

1.创建HashMap <Node,Node>,遍历节点，存入map中；

2.复制next和random指针；

 

进阶：不使用额外的数据结构，只用有限几个变量，且在时间复杂度为 O(N)

内完成原问题要实现的函数。

1.在每个节点后复制一个节点；

2.将random指针复制；

3.将next指针复原；

 

实现：

package class_03;

import java.io.ObjectInputStream.GetField;
import java.util.HashMap;
import java.util.Map;

import javax.xml.transform.Templates;

/*
 * 复制含有随机指针节点的链表
【题目】 一种特殊的链表节点类描述如下：
public class Node { 
    public int value; 
    public Node next; 
    public Node rand;
    public Node(int data) 
    { 
        this.value = data; 
    }s
}
Node类中的value是节点值，next指针和正常单链表中next指针的意义一 样，都指向下一个节点，
rand指针是Node类中新增的指针，这个指针可 能指向链表中的任意一个节点，也可能指向null。 
给定一个由Node节点类型组成的无环单链表的头节点head，请实现一个 函数完成这个链表中所有结构的复制，
并返回复制的新链表的头节点。 
进阶：不使用额外的数据结构，只用有限几个变量，且在时间复杂度为 O(N)内完成原问题要实现的函数。
 */
public class Code_13_CopyListWithRandom {
    public static class Node {
        public int value;
        public Node next;
        public Node rand;

        public Node(int data) {
            this.value = data;
        }
    }
    public static Node copyListWithRand1(Node head) {
        HashMap<Node, Node> map = new HashMap<>();
        Node cur = head;
//        while (cur != null) {
//            map.put(cur, new Node(cur.value));
//            map.get(cur).next = map.get(cur.next);//get(cur.next)可能没有值;
//            map.get(cur).rand = map.get(cur.rand);//get(cur.rand)可能没有值;所以要分开两次遍历;
//            cur = cur.next;
//        }
        //复制节点值，并存入对应HashMap中;
        while (cur != null) {
            map.put(cur, new Node(cur.value));
            cur = cur.next;
        }
        cur = head;
        //复制指针指向；
        while (cur != null) {
            map.get(cur).next = map.get(cur.next);
            map.get(cur).rand = map.get(cur.rand);
            cur = cur.next;
        }
        return map.get(head);        
    }
    
    /*
     * 1.创建HashMap<Node,Node>,遍历节点，存入map中；
     * 2.复制next和random指针；
     */
    public static Node copyListWithRand3(Node head) {
        if (head == null) {
            return null;
        }
        Node cur = head;
        Map<Node, Node> map = new HashMap<>();
        //1.创建HashMap<Node,Node>,遍历节点，存入map中；
        while (cur != null) {
            map.put(cur, new Node(cur.value));
            cur = cur.next;
        }
        //2.复制next和random指针；
        cur = head;
        while (cur != null) {
            map.get(cur).next = map.get(cur.next);
            map.get(cur).rand = map.get(cur.rand);
            cur = cur.next;
        }
        //3.返回复制链表的首节点;
        return map.get(head);
    }
    
    /*正确！！！
     * 1.在每个节点后复制一个节点；
     * 2.将random指针复制；
     * 3.将next指针复原；
     */
    public static Node copyListWithRand4(Node head) {
        if (head == null) {
            return null;
        }
        Node cur = head;
        Node next = null;
        //1.在每个节点后复制一个节点；
        while (cur != null) {
            next = cur.next;
            cur.next = new Node(cur.value);
            cur.next.next = next;
            cur = next;
        }
        //2.将random指针复制；
        cur = head;
//        Node curCopy = cur.next;
        next = cur.next;
        while (cur != null) {
            next.rand = cur.rand != null ? cur.rand.next : null;
            cur = next.next;
            if (cur != null) {
                next = cur.next;
            }            
        }
        //将next指针复原；
        cur = head;
        next = cur.next;
        while (cur != null && next.next != null) {
            cur = next.next;
            next.next = cur.next;
            next = cur.next;
        }
        return head.next;
    }
    
    
    
    
    
    
    
    
    
    
    
    /*
     * 有问题！！！
     */
    public static Node copyListWithRand2(Node head) {
        if (head == null) {
            return null;
        }
        //每个节点后都插入一个新节点；
        Node cur = head;
        Node next = null ;
        while (cur != null) {
            next = cur.next;
            cur.next = new Node(cur.value);
            cur.next.next = next;
            cur = next;
            
        }
        cur = head;
        next = cur.next;
        while (cur != null) {
            next.rand = cur.rand.next;
            cur = next.next;
        }
        
    
        cur = head.next;
        next = cur.next;
        while (next != null) {
            cur.next = next.next;            
            cur = cur.next;
            next = cur.next == null ? null : cur.next;
        }
        
        return head.next;        
    }
    
    public static void printRandLinkedList(Node head) {
        Node cur = head;
        System.out.print("order: ");
        while (cur != null) {
            System.out.print(cur.value + " ");
            cur = cur.next;
        }
        System.out.println();
        cur = head;
        System.out.print("rand:  ");
        while (cur != null) {
            System.out.print(cur.rand == null ? "- " : cur.rand.value + " ");
            cur = cur.next;
        }
        System.out.println();
    }
    
    private static void test() {
        // TODO Auto-generated method stub
        Node head = null;
        Node res1 = null;
        Node res2 = null;
        printRandLinkedList(head);
        res1 = copyListWithRand1(head);
        printRandLinkedList(res1);
        res2 = copyListWithRand2(head);
        printRandLinkedList(res2);
        printRandLinkedList(head);
        System.out.println("===========***==========");

        head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(4);
        head.next.next.next.next = new Node(5);
        head.next.next.next.next.next = new Node(6);

        head.rand = head.next.next.next.next.next; // 1 -> 6
        head.next.rand = head.next.next.next.next.next; // 2 -> 6
        head.next.next.rand = head.next.next.next.next; // 3 -> 5
        head.next.next.next.rand = head.next.next; // 4 -> 3
        head.next.next.next.next.rand = null; // 5 -> null
        head.next.next.next.next.next.rand = head.next.next.next; // 6 -> 4

//        printRandLinkedList(head);
//        res1 = copyListWithRand1(head);
//        printRandLinkedList(res1);
//        res2 = copyListWithRand2(head);
//        printRandLinkedList(res2);
//        printRandLinkedList(head);
        System.out.println("=========================");
        printRandLinkedList(head);
        res1 = copyListWithRand3(head);
        printRandLinkedList(res1);
        res2 = copyListWithRand4(head);
        printRandLinkedList(res2);
        System.out.println("=========================");
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        test();
    }


    

}

输出：

order: 
rand:  
order: 
rand:  
order: 
rand:  
order: 
rand:  
===========***==========
=========================
order: 1 2 3 4 5 6 
rand:  6 6 5 3 - 4 
order: 1 2 3 4 5 6 
rand:  6 6 5 3 - 4 
order: 1 2 3 4 5 6 
rand:  6 6 5 3 - 4 
=========================

5.6 比价两个链表是否相交（链表可能有环）

在本题中，单链表可能有环，也可能无环。给定两个单链表的头节点 head1和head2，这两个链表可能相交，也可能不相交。请实现一个函数， 如果两个链表相交，请返回相交的第一个节点；如果不相交，返回null 即可。 

要求：如果链表1的长度为N，链表2的长度为M，时间复杂度请达到 O(N+M)，额外空间复杂度请达到O(1)。

通过分析：当没有环时，一共有两种情况：

无环时，记录两个链表的长度，找到长度差n，然后长的先走n步，即可。有环2同无环2情况。

当有环时，一共有3种情况：

当一个有环，一个无环，一定不会相交。

思路1：使用额外空间。判断是否相交，可以使用Hashmap，先将一个链表遍历完，填入map中，然后遍历链表2，看是否map中有该元素，如果有的话，就表示相交，如果没有就表示不相交。

思路2：不使用额外空间。使用两对变量head1，head2，loop1，loop2（loop表示循环进入点）。

1. 判断head1和head2是否为null；
2. 通过head1和head2得到loop1和loop2；getLoopNode(head);
3. 判断loop1和loop2是否都是null；

3.1都是null说明都是直链表；noLoop(head1,head2);

3.2一个是null一个不是null，肯定返回null；

3.3都不是null，分三种情况。bothLoop(head1,head2); 有环2同无环2情况，有环1,2可直接判断。

实现：

public static class Node {
        public int value;
        public Node next;

        public Node(int data) {
            this.value = data;
        }
    }
    
    public static Node getIntersectNode(Node head1, Node head2) {
        if (head1 == null || head2 == null) {
            return null;
        }
        Node loop1 = getLoopNode(head1);
        Node loop2 = getLoopNode(head2);
        if (loop1 == null && loop2 == null) {
            return noLoop(head1,head2,loop1,loop2);
        }
        if (loop1 != null && loop2 != null) {
            return bothLoop(head1,head2,loop1,loop2);
        }
        return null;        
    }
    
    private static Node bothLoop(Node head1, Node head2, Node loop1, Node loop2) {
        //有三种情况：1.66型；2.Y0型；3.O/型；
        Node n1 = head1;
        Node n2 = head2;
        int len1 = 0;
        if (loop1 == loop2) {
            //说明是第二种；
            return noLoop(head1, head2, loop1, loop2);
        }else {
            //顺着loop往下遍历，是否能够遇到另一个loop；能遇到则是O/型，否则是66型；
            n1 = loop1.next;
            while (n1 != loop1) {
                if (n1 == loop2) {
                    return loop1;//或者返回loop2，均可；
                }
                n1 = n1.next;
            }
        }
        return null;
    }

    private static Node noLoop(Node head1, Node head2, Node loop1, Node loop2) {
        Node n1 = head1;
        Node n2 = head2;
        int len1 = 0;
        int len2 = 0;
        while (n1 != loop1) {
            n1 = n1.next;
            len1++;
        }
        while (n2 != loop2) {
            len2++;
            n2 = n2.next;
        }
        //n1指向较长的链表；
        n1 = len1 >= len2 ? head1 : head2;
        n2 = len1 >= len2 ? head2 : head1;
        len1 = Math.abs(len1-len2);
        while (len1>0) {
            n1 = n1.next;
            len1--;
        }
        //直到相等即证明该节点是重合开始节点；
        while (n1 != n2) {
            n1 = n1.next;
            n2 = n2.next;
        }

        return n1;
    }

    private static Node getLoopNode(Node head) {
        Node f = head;
        Node s = head;
        if (head == null || head.next == null || head.next.next == null) {
            return null;
        }
        f = f.next.next;
        s = s.next;
        while (f != s) {
            if (f.next == null || f.next.next == null) {
                return null;
            }
            s = s.next;
            f = f.next.next;
        }
        f = head;        
        while(f != s) {
            f = f.next;
            s = s.next;
        }
        return s;
    }

 

卧槽，连夜肝了一篇纯干货，欢迎大家点赞评论，嘻嘻~~

Over......