数据结构_单链表操作总结

package zz;

import java.util.Stack;

/**
 * 
 * @author zz
 * 关于java中链表的操作
 * 0. 向链表中插入新节点
 * 1. 求单链表中结点的个数: getListLength 
 * 2. 将单链表反转: reverseList（遍历），reverseListRec（递归） 
 * 3. 查找单链表中的倒数第K个结点（k > 0）: reGetKthNode 
 * 4. 查找单链表的中间结点: getMiddleNode 
 * 5. 从尾到头打印单链表: reversePrintListStack，reversePrintListRec（递归） 
 * 6. 已知两个单链表pHead1 和pHead2 各自有序，把它们合并成一个链表依然有序: mergeSortedList, mergeSortedListRec 
 * 7. 对链表的后半部分进行反转。reversePartNode
 * 8. 判断单链表是否存在环，isLoop。 使用两个指针，fast和low，fast一次走两步，low一次走一步。若存在环，总会有某个时刻fast和low指向同一节点
 * 9. 求出环的长度。getLoopLength().记录8中fast和low的遭遇点。然后让low走一圈环记数即可
 * 10. 对单链表进行排序,listSort（归并）,insertionSortList（插入）
 * // 注释部分代码也经过调试正确
 */
public class LinkedListSummary {
    public static class Node {
        int data;
        Node next;
        public Node(int value) {
            data = value;
            next = null;
        }
    }
    //向链表中插入新节点
    public static void addNode(Node head, int data) {
        Node newNode = new Node(data);
        if(head == null) {
            head = newNode;
            return;
        } else {
            Node temp = head;
            while(temp.next != null) {
                temp = temp.next;
            }
            temp.next = newNode;            
        }
    }
    //输出链表的长度
    public static int getListLength(Node head) {
        int len = 0;
        //if(head == null) return 0;
        Node temp = head;
        while(temp != null) {
            len++;
            temp = temp.next;
        }
        System.out.println("输出链表长度：" + len);
        return len;
    }    
    //顺序打印链表数据 
    public static void print(Node head) {
       if(head == null) {
           System.out.println("链表为空");
           return;
       }
       Node temp = head;
       while(temp != null) {
           System.out.print(temp.data + " ");
           temp = temp.next;
       }
    }
    //方法1：使用栈反向遍历单链表
    public static void reversePrint(Node head) {
        if(head == null || head.next == null) return;
        Stack<Node> nodes = new Stack<Node>();
        Node temp = head;
        while(temp != null) {
            nodes.push(temp);
            temp = temp.next;
        }
        while(!nodes.isEmpty()) {
            //nodes.pop();
            System.out.print(nodes.pop().data + " ");
        }
    }
    //方法二：反向遍历单链表
    public static Node reversePrint2(Node head) {
        if(head == null || head.next == null) return head;
        Node pre = null;
        Node temp = null;
        while(head != null) {
            temp = head.next;
            head.next = pre;
            pre = head;
            head = temp;
        } 
        print(pre);
    //    System.out.println(head == null ? "空" : "非空");
        return pre;
    }    
    //递归反向遍历单链表
    public static Node reversePrintRec(Node head) {
        if(head == null || head.next == null) {
            System.out.println("链表遍历完成，只有head节点或为空链表");
            return head;
        }
        Node reHead = reversePrintRec(head.next);
         head.next.next = head;
        head.next = null;
        return head;
    }
    //从尾到头打印递归打印单链表
    public static void reversePrintListRec(Node head) {
        if(head == null) {
            return;
        } else {
            reversePrintListRec(head.next);
            System.out.print(head.data + ",");
        }
    }
    //查找单链表的倒数第K个节点（k>0）
    public static Node reGetKthNode(Node head, int k) {
        int len = 0;
        Node temp = head;
        while(temp != null) {
            len++;
            temp = temp.next;
        }
        if(k > len) {
            System.out.println("链表长度有限，小于K，找不到倒数第K个节点");
            return null;
        }
        Node n1 = head;
        Node n2 = head;
        for(int i = 0; i < k; i++) {
            n1 = n1.next;
        }
        while(n1 != null){
            n2 = n2.next;
            n1 = n1.next;
        }
        System.out.println(n2.data);
        return n2;
    }
    //查找单链表的中间结点: getMiddleNode
    public static Node getMiddleNode(Node head) {
        if(head == null || head.next == null) return head;
        Node n1 = head;
        Node n2 = head;
        while(n2 != null && n2.next != null) {
            n1 = n1.next;
            n2 = n2.next.next;
        }
        //System.out.println(n1.data);
        return n1;
    }
    //已知两个单链表pHead1 和pHead2 各自有序，把它们合并成一个链表依然有序: mergeSortedList
    public static Node mergeSortedList(Node head1, Node head2) {
        if(head1 == null) return head2;
        if(head2 == null) return head1;
        Node target = null;
        if(head1.data > head2.data) {
            target = head2;
            head2 = head2.next;
        } else {
            target = head1;
            head1 = head1.next;
        } 
        target.next = null;
        Node newHead = target;
        while(head1 != null && head2 != null) {
            if(head1.data > head2.data) {
                target.next = head2;
                head2 = head2.next;
            } else {
                target.next = head1;
                head1 = head1.next;
            }
            target = target.next;
            target.next = null;
        }
        if(head1 == null) {
            target.next = head2;
        } else {
            target.next = head1; 
        }
        return newHead;
    }
    //已知两个单链表pHead1 和pHead2 各自有序，把它们合并成一个链表依然有序(递归实现): mergeSortedListRec
    public static Node mergeSortedListRec(Node head1, Node head2) {
        if(head1 == null) return head2;
        if(head2 == null) return head1;
        Node head = null;
        if(head1.data > head2.data) {
            head = head2;
            head.next = mergeSortedListRec(head2.next, head1);
        } else {
            head = head1;
            head.next = mergeSortedListRec(head1.next, head2);
        }
         return head;
    }
    //将链表的后半部分进行反转
    public static Node reversePartNode(Node head){  
        Node flag = head;
        Node cur = null;
        Node mid = getMiddleNode(head);
        
        while(flag.next != mid) {     //取出中间节点的 前一个节点并保存
            flag = flag.next;
        }
        Node pre = null;
        //System.out.println("----" + flag.data);
        while(mid != null) {
            cur = mid.next;
            mid.next = pre; 
            pre = mid;
            mid = cur;
        } 
       
        flag.next = pre;
        print(head);

        return head;
    }  
    //判断链表是否存在环
    public static boolean isLoop(Node head) {
        if(head == null || head.next != null) return false;
        Node fast = head;
        Node low = head;
        while(fast != null && fast.next != null) {
            low = low.next;
            fast = fast.next.next;
            if(fast == low) break;
        }
        if(fast == null || fast.next == null) return false;
        return true;
    }
    //求出环的长度
    public static int getLoopLength(Node head) {
        if(head == null || head.next != null) return 0;
        Node fast = head;
        Node low = head;
        while(fast != null && fast.next != null) {
            low = low.next;
            fast = fast.next.next;
            if(fast == low) break;
        }
        if(fast == null || fast.next == null) return 0;
        else {
            int loopLen = 1;
            while(low.next != fast) {
                loopLen++;
                low = low.next;
            }
            return loopLen;
        }
        
    }
/*  
    //单链表排序
    public static Node listSort(Node head) {
        Node nex = null;
        if(head == null || head.next == null) return head;
        else if(head.next.next == null) {
            nex = head.next;
            head.next = null;
        } else {
            Node mid = getMiddleNode(head);
            nex = mid.next;
            mid.next = null;
        }
        print(mergeSortedList(listSort(head), listSort(nex)));
        return mergeSortedList(listSort(head), listSort(nex));
    }
*/
    public static void main(String[] args) {
        Node head = new Node(0);
        addNode(head, 6);
        addNode(head, 2);
        addNode(head, 1);
        addNode(head, 4);
        addNode(head, 3);
        addNode(head, 5);
    //    listSort(head);
        System.out.println("顺序打印链表数据：");
        print(head);
        System.out.println();
        System.out.println("反转单链表后半部分节点：");
        reversePartNode(head);
        System.out.println();
        
        if(isLoop(head)) {
            System.out.println("存在环");
        } else System.out.println("不存在环");
        
        Node head1 = new Node(10);
        addNode(head1, 11);
        addNode(head1, 12);
        addNode(head1, 13);
        addNode(head1, 14);
        addNode(head1, 15);
        addNode(head1, 16);
        addNode(head1, 17);
        addNode(head1, 18);
        addNode(head1, 19);
        addNode(head1, 20);
        /*
        System.out.println();
        System.out.println("反转单链表后半部分节点：");
        reversePartNode(head1);
        System.out.println();
        */
        Node head2 = new Node(100);
        for(int i = 0; i < 8; i++) {
            addNode(head2, 100+i);
        }
        
        Node head3 = new Node(1000);
        for(int i = 0; i < 8; i++) {
            addNode(head3, 1001+i);
        }
        
        getListLength(head);
        System.out.println("顺序打印链表数据：");
        print(head);
    /*
    //    System.out.println();
    //    System.out.println("使用栈反转链表:");
    //    reversePrint(head);
    //    System.out.println();
    //    reversePrint2(head);
    //    System.out.println();
    //    System.out.println("递归反向遍历单链表");
    //    System.out.println("----" + head.data);
    //    reversePrintListRec(head);
    //    System.out.println();
    //    System.out.println("查找单链表的倒数第K个节点的值");
    //    reGetKthNode(head, 3);
    //    System.out.println();
    //    System.out.println("查找单链表的中间节点的值");
    //    getMiddleNode(head);
    //    System.out.println();
    //    System.out.println("合并两个单链表：");
    //    Node mergeHead = mergeSortedList(head, head1);
    //    print(mergeHead);
    //    System.out.println();
    //    System.out.println("递归实现合并两个单链表：");
    //    Node mergeHeadRec = mergeSortedListRec(head2, head3);
    //    print(mergeHeadRec);
        */
    } 
}