Java_實現單鏈表-基本操作

一、通過JAVA實現單鏈表

　　增刪改查、返回長度、反轉、查找、排序

二、代碼

package officeCoding;

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

/**
 * 從尾到頭遍歷鏈表 輸入一個鏈表，按鏈表值從尾到頭的順序返回一個ArrayList
 * 
 * @author Administrator
 */
class ListNode {// 單鏈表節點構建
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}

public class Pro_03 {

    static ListNode head = null;// 創建一個頭節點

    public static void main(String[] args) {
        addNode(5);
        addNode(8);
        ArrayList<Integer> list = printListFromTailToHead(head);
        System.out.println(list);
    }

    // 隊列和棧是一對好基友，從尾到頭打印鏈表，當然離不開借助棧的幫忙啦
    // 所以，先把鏈表里的東西，都放到一個棧里去，然后按順序把棧里的東西pop出來，就這么簡單
    public static ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        Stack<Integer> stack = new Stack<Integer>();
        while (listNode != null) {
            stack.push(listNode.val);
            listNode = listNode.next;
        }
        ArrayList<Integer> list = new ArrayList<Integer>();
        while (!stack.isEmpty()) {
            list.add(stack.pop());
        }
        return list;
    }

    // input
    public static void addNode(int d) {
        ListNode newNode = new ListNode(d);
        if (head == null) {
            head = newNode;
        }
        ListNode tmp = head;
        while (tmp.next != null) {
            tmp = tmp.next;
        }
        tmp.next = newNode;
    }

    // delete
    public boolean deleteNode(int index) {
        if (index < 1 || index > length()) {
            return false;// 如果當前index在鏈表中不存在
        }
        if (index == 1) {// 如果index指定的是頭節點
            head = head.next;
            return true;
        }
        int i = 2;
        ListNode preNode = head;// 前一個節點（從頭節點開始）
        ListNode curNode = preNode.next;// 當前節點
        while (curNode != null) {
            if (i == index) {
                preNode.next = curNode.next;// 刪除當節點，前節點連接到下節點
                return true;
            }
            preNode = curNode;
            curNode = curNode.next;
            i++;
        }
        return false;
    }

    // 返回節點長度

    public int length() {
        int length = 0;
        ListNode tmp = head;
        while (tmp != null) {
            length++;
            tmp = tmp.next;
        }
        return length;
    }

    // 鏈表反轉

    public ListNode ReverseIteratively(ListNode head) {
        ListNode pReversedHead = head;
        ListNode pNode = head;
        ListNode pPrev = null;
        while (pNode != null) {
            ListNode pNext = pNode.next;
            if (pNext == null) {
                pReversedHead = pNode;
            }
            pNode.next = pPrev;
            pPrev = pNode;
            pNode = pNext;
        }
        this.head = pReversedHead;
        return this.head;
    }

    // 查找單鏈表的中間節點

    public ListNode SearchMid(ListNode head) {
        ListNode p = this.head, q = this.head;
        while (p != null && p.next != null && p.next.next != null) {
            p = p.next.next;
            q = q.next;
        }
        System.out.println("Mid:" + q.val);
        return q;
    }

    // 查找倒數 第k個元素

    public ListNode findElem(ListNode head, int k) {
        if (k < 1 || k > this.length()) {
            return null;
        }
        ListNode p1 = head;
        ListNode p2 = head;
        for (int i = 0; i < k; i++)// 前移k步
            p1 = p1.next;
        while (p1 != null) {
            p1 = p1.next;
            p2 = p2.next;
        }
        return p2;
    }

    // 排序

    public ListNode orderList() {
        ListNode nextNode = null;
        int tmp = 0;
        ListNode curNode = head;
        while (curNode.next != null) {
            nextNode = curNode.next;
            while (nextNode != null) {
                if (curNode.val > nextNode.val) {
                    tmp = curNode.val;
                    curNode.val = nextNode.val;
                    nextNode.val = tmp;
                }
                nextNode = nextNode.next;
            }
            curNode = curNode.next;
        }
        return head;
    }

    // 從尾到頭輸出單鏈表，采用遞歸方式實現

    public void printListReversely(ListNode pListHead) {
        if (pListHead != null) {
            printListReversely(pListHead.next);
            System.out.println("printListReversely:" + pListHead.val);
        }
    }

    // 判斷鏈表是否有環，單向鏈表有環時，尾節點相同

    public boolean IsLoop(ListNode head) {
        ListNode fast = head, slow = head;
        if (fast == null) {
            return false;
        }
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow) {
                System.out.println("該鏈表有環");
                return true;
            }
        }
        return !(fast == null || fast.next == null);
    }

    // 找出鏈表環的入口

    public ListNode FindLoopPort(ListNode head) {
        ListNode fast = head, slow = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast)
                break;
        }
        if (fast == null || fast.next == null)
            return null;
        slow = head;
        while (slow != fast) {
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }
}