练习一下java单链表的简单习题

package com.test1;

import java.util.Stack;

public class SingleListDemo {
    
    /**
     * 返回单链表的总长度
     * @param sl
     * @return
     */
    public static <T> int getListLength(SingleList<T> sl) {
        Node<T> temp = sl.headNode.next;
        int index = 0;
        while(temp != null) {
            temp = temp.next;
            index++;
        }
        return index;
    }
    
    /**
     * 查找单链表中倒数第k个元素
     * @param sl
     * @param k
     * @return
     */
    public static <T> Node<T> getLastK(SingleList<T> sl, int k){
        int length = getListLength(sl);
        if(length < k) {
            throw new RuntimeException("不存在倒数第" + k + "个节点");
        }
        int index = length - k;
        Node<T> temp = sl.headNode.next;
        while(index != 0) {
            temp = temp.next;
            index--;
        }
        return temp;
    }
    
    /**
     * 单链表的反转
     * @param <T>
     * @param args
     */
    public static <T> void reverseList(SingleList<T> sl){
        int length = getListLength(sl);
        if(length == 1) {
            return;
        }
        
        Node<T> headNode = sl.headNode;
        Node<T> last =  headNode.next;
        Node<T> cur = last.next;
        Node<T> next = cur.next;
        last.next = null;
        while(next != null) {
            cur.next = last;
            last = cur;
            cur = next;
            next = next.next;
        }
        cur.next = last;
        sl.headNode.next = cur;
    }
    
    /**
     * 从尾到头打印单链表 (利用栈)
     * @param <T>
     * @param args
     */
    public static <T> void printReverseList1(SingleList<T> sl) {
        Node<T> temp = sl.headNode.next;
        Stack<T> stack = new Stack<>();
        while(temp != null) {
            stack.push(temp.data);
            temp = temp.next;
        }
        while(!stack.empty()) {
            System.out.println(stack.pop());
        }
    }
    
    /**
     * 从尾到头打印单链表 (利用递归) 很是牛逼！
     * @param <T>
     * @param args
     */
    public static <T> void printReverseList2(Node<T> node) {
        if(node.next != null) {
            printReverseList2(node.next);
        }
        System.out.println(node.data);
    }
    
    /**
     * 合并两个有序的单链表，合并之后的单链表任然有序
     * @param <T>
     * @param args
     */
    public static <T> SingleList<T> mergeTwoList(SingleList<T> sl1, SingleList<T> sl2) {
        SingleList<T> result = new SingleList<>();
        Node<T> temp1 = sl1.headNode.next;
        Node<T> temp2 = sl2.headNode.next;
        while(temp1 != null && temp2 != null) {
            if(temp1.compareTo(temp2) < 0) {
                Node<T> temp = temp1;
                temp1 = temp1.next;
                temp.next = null;
                result.addNode(temp);
            } else {
                Node<T> temp = temp2;
                temp2 = temp2.next;
                temp.next = null;
                result.addNode(temp);
            }
        }
        Node<T> temp = temp1 == null ? temp2 : temp1;
        while(temp != null) {
            result.addNode(temp);
            temp = temp.next;
        }
        return result;
    }
    
    public static void main(String[] args) {
//      SingleList<String> sl = new SingleList<>();
//      sl.addNode(new Node<>("李四", null));
//      sl.addNode(new Node<>("张三", null));
//      sl.addNode(new Node<>("王五", null));
//      sl.addNode(new Node<>("赵六", null));
//      sl.showData();
//      System.out.println(getListLength(sl));
//      Node<String> node = getLastK(sl, 2);
//      System.out.println(node);
//      reverseList(sl);
//      System.out.println("\n反转之后为：");
//      sl.showData();
//      System.out.println("\n从尾到头打印单链表");
//      printReverseList2(sl.headNode.next);
//      Node<Integer> a = new Node<>(1, null);
//      Node<Integer> b = new Node<>(2, null);
//      System.out.println(a.compareTo(b));
        
        SingleList<Integer> sl = new SingleList<>();
        sl.addNodeOrder(new Node<>(1, null));
        sl.addNodeOrder(new Node<>(3, null));
        sl.addNodeOrder(new Node<>(70, null));
        sl.addNodeOrder(new Node<>(2, null));
        sl.showData();
        SingleList<Integer> sl1 = new SingleList<>();
        sl1.addNodeOrder(new Node<>(11, null));
        sl1.addNodeOrder(new Node<>(13, null));
        sl1.addNodeOrder(new Node<>(17, null));
        sl1.addNodeOrder(new Node<>(12, null));
        sl1.showData();
        System.out.println("\n合并之后为：");
        SingleList<Integer> result = mergeTwoList(sl, sl1);
        result.showData();
    }
}

class Node<T> implements Comparable<Node<T>>{
    public T data;
    public Node<T> next;
    public Node(T data, Node<T> next) {
        super();
        this.data = data;
        this.next = next;
    }
    @Override
    public String toString() {
        return this.data.toString();
    }
    
    
    @SuppressWarnings("unchecked")
    @Override
    public int compareTo(Node<T> o) {
        if(o.data instanceof Comparable) {
            return ((Comparable<Comparable<?>>) this.data).compareTo((Comparable<?>) o.data);
        }
        return 0;
    }
    
}

class SingleList<T>{
    public Node<T> headNode = new Node<>(null, null);
    
    /**
     * 往尾部添加节点
     * @param node
     */
    public void addNode(Node<T> node) {
        Node<T> temp = headNode;
        while(temp.next != null) {
            temp = temp.next;
        }
        temp.next = node;
    }
    
    /**
     * 按照节点的大小添加节点，使得链表有序
     */
    public void addNodeOrder(Node<T> node) {
        Node<T> last = headNode;
        Node<T> temp = last.next;
        while(temp != null && temp.compareTo(node) < 0) {
            last = temp;
            temp = temp.next;
        }
        if(temp != null && temp.compareTo(node) == 0) {
            throw new RuntimeException("已经存在相同的节点，不允许再次添加");
        }
        last.next = node;
        node.next = temp;
    }
    
    /**
     * 显示list中的数据
     */
    public void showData() {
        Node<T> temp = headNode.next;
        while(temp != null) {
            System.out.print(temp + " ");
            temp = temp.next;
        }
    }
    
    
}