单链表常见操作

最近在重新学习数据结构和算法的知识，数据结构和算法问题本身比较枯燥和乏味，而且比较难不容易掌握，但是属于程序员内功的一部分，学习起来容易上瘾。

1. 单链表定义

package algorithm.datastructors;

/**
 * 单向链表
 * @author i324779
 */
public class ListNode {

    private int data;

    private ListNode next;

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

    public int getData() {
        return data;
    }

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

    public ListNode getNext() {
        return next;
    }

    public void setNext(ListNode next) {
        this.next = next;
    }
}

2, 单链表的一些常见操作

package algorithm.datastructors;

import java.util.Stack;

/**
 * 单链表的一些操作
 *
 * @author i324779
 */
public class ListNodeOperation {

    /**
     * 找到链表的中间节点
     * 使用两个指针。让第一个指针的移动速度是另一个的两倍。
     * 当第一个指针到达表尾时，另一个指针则指向中间节点。
     * Note：如果链表节点数为奇数，则第（n/2）个节点为中间节点。
     *
     * @param head
     * @return
     */
    ListNode findMiddle(ListNode head) {
        ListNode ptr1x, ptr2x;
        ptr1x = head;
        ptr2x = head;
        int i = 0;
        // 不断循环，直至达到表尾（next后继指针为null，就表示达到最后一个节点）
        while (ptr1x.getNext() != null) {
            if (i == 0) {
                ptr1x = ptr1x.getNext();
                i = 1;
            } else {
                // 两个指针都后移
                ptr1x = ptr1x.getNext();
                ptr2x = ptr2x.getNext();
                i = 0;
            }
        }
        return ptr2x;
    }

    /**
     * 从表尾开始输出链表。
     *
     * @param head
     */
    void printListFromEnd(ListNode head) {
        if (head == null) {
            return;
        }

        printListFromEnd(head.getNext());
        System.out.println(head.getData());
    }

    /**
     * 检查链表的长度是奇数还是偶数。
     * 使用一个在链表中每次向后移动两个节点的指针。
     * 最后，如果指针值为null，那么聊表长度为偶数；
     * 否则指针指向表尾节点，链表长度为奇数。
     *
     * @param head
     * @return
     */
    public int isLinkedListLengthEven(ListNode head) {
        while (head != null && head.getNext() != null) {
            head = head.getNext().getNext();
        }
        if (head == null) {
            return 0;
        } else {
            return 1;
        }
    }

    /**
     * 合并两个有序链表为一个新的有序链表。
     *
     * @param node1
     * @param node2
     * @return
     */
    public ListNode mergeList(ListNode node1, ListNode node2) {
        if (node1 == null) {
            return node2;
        }
        if (node2 == null) {
            return node1;
        }

        ListNode result;
        if (node1.getData() <= node2.getData()) {
            result = node1;
            result.setNext(mergeList(node1.getNext(), node2));
        } else {
            result = node2;
            result.setNext(mergeList(node2.getNext(), node1));
        }
        return result;
    }

    /**
     * 逆置单向链表。
     *
     * @param head 表头
     * @return 逆置后的单向链表。
     */
    ListNode reverseList(ListNode head) {
        ListNode temp = null;
        ListNode nextNode;

        while (head != null) {
            nextNode = head.getNext();
            head.setNext(temp);
            temp = head;
            head = nextNode;
        }

        return temp;
    }

    /**
     * 找到链表的倒数第n个结点
     * 使用一次链表扫描解决问题。
     * 使用两个指针pNthNode和pTemp。
     * 首先，两个指针都指向链表的头结点。仅当pTemp（沿着链表）进行了n次移动后，
     * pNthNode才开始移动。然后两个指针同时移动直至tTemp到达表尾。
     * 这时pNthNode指针所指的结点就是所求的结点，也就是链表的倒数第n个结点。
     *
     * @param head
     * @param nthNode
     * @return
     */
    ListNode nthNodeFromEnd(ListNode head, int nthNode) {
        ListNode pTemp = head;
        ListNode pNnthNode = null;

        for (int count = 1; count < nthNode; count++) {
            if (pTemp != null) {
                pTemp = pTemp.getNext();
            }
        }

        while (pTemp != null) {
            if (pNnthNode == null) {
                pNnthNode = head;
            } else {
                pNnthNode = pNnthNode.getNext();
            }

            pTemp = pTemp.getNext();
        }
        return pNnthNode;
    }

    /**
     * 给定两个有序单链表的头指针head1 和head2， 打印两个链表的公共部分。
     *
     * @param head1 有序链表1
     * @param head2 有序链表2
     */
    public void printCommonPart(ListNode head1, ListNode head2) {
        if (head1 == null || head2 == null) {
            System.out.println("Node is null");
            return;
        }

        System.out.println("Common Part: ");
        while (head1 != null && head2 != null) {
            if (head1.getData() < head2.getData()) {
                head1 = head1.getNext();
            } else if (head1.getData() > head2.getData()) {
                head2 = head2.getNext();
            } else {
                System.out.println(head1.getData());
                head1 = head1.getNext();
                head2 = head2.getNext();
            }
        }
    }

    /**
     * 判断是否有环
     *
     * @param head 链表头结点
     * @return 是否有环
     */
    public static boolean isCycle(ListNode head) {
        ListNode p1 = head;
        ListNode p2 = head;

        while (p2 != null && p2.getNext() != null) {
            p1 = p1.getNext();
            p2 = p2.getNext().getNext();

            if (p1 == p2) {
                return true;
            }
        }

        return false;
    }

    /**
     * 逐对逆置链表
     *
     * @param head
     * @return
     */
    private void reversePairRecursive(ListNode head) {
        if (head == null || head.getNext() == null) {
            return;
        }

        ListNode cur = head.getNext();
        ListNode pre = head;
        ListNode next;

        while (cur != null && cur.getNext() != null) {
            next = cur.getNext().getNext();
            pre.setNext(cur.getNext());
            cur.getNext().setNext(cur);
            cur.setNext(next);
            pre = cur;
            cur = next;
        }

    }

    /**
     * 判断一个链表是否为回文结构
     *
     * @param head 单链表的头结点
     * @return true：回文结构；false：不是回文结构
     */
    public boolean isPalindrome(ListNode head) {
        Stack<ListNode> stack = new Stack<>();
        ListNode cur = head;

        while (cur != null) {
            stack.push(cur);
            cur = cur.getNext();
        }

        while (head != null) {
            if (head.getData() != stack.pop().getData()) {
                return false;
            }
            head = head.getNext();
        }

        return true;
    }


    public static void main(String[] args) {
        ListNodeOperation operation = new ListNodeOperation();
        int i = 1;
        ListNode head = new ListNode();
        head.setNext(null);
        ListNode tmp;
        ListNode cur = head;

        for (; i < 8; i++) {
            tmp = new ListNode();
            tmp.setData(i);
            tmp.setNext(null);
            cur.setNext(tmp);
            cur = tmp;
        }

        System.out.println("顺序输出：");
        for (cur = head.getNext(); cur != null; cur = cur.getNext()) {
            System.out.print(cur.getData() + " ");
        }

        operation.reversePairRecursive(head);

        System.out.println("\n逆序输出：");
        for (cur = head.getNext(); cur != null; cur = cur.getNext()) {
            System.out.print(cur.getData() + " ");
        }
    }
}