Java 基于泛型实现的单链表以及基本操作

可通过传递一个数组实现链表的初始化
倒序打印链表时，采用的递归。也可采用栈的方法实现。

定义节点类：

public class Node<T> {
    public T data; // 节点的数据
    public Node<T> nextNode; // 子节点
    public Node() { 
    }
    public Node(T data) {
        this.data = data;
    }
}

定义链表类：

public class LinkList<T> {
    public Node<T> headNode; // 头结点
    public int LenOfLinkList; //链表长度
    
    
    public LinkList(){
    }
    /**
     * 传递一个数组初始化链表
     * @param initialData
     */
    public LinkList(T[] initialData ){
        if(initialData.length == 0) {
            this.headNode = new Node<T>();
        }else {
            this.headNode = new Node<T>();
            this.headNode.data = initialData[0]; // 头结点赋值
            this.LenOfLinkList = 1;
            Node<T> p = this.headNode; // 复制头结点的地址
            for(int i=1; i<initialData.length; i++) {
                Node<T> x = new Node<T>(); // 新建子节点
                x.data = initialData[i]; // 初始化子节点数据
                p.nextNode = x; // 子节点插入链表
                p = x; // p指向下一节点
                this.LenOfLinkList++; // 链表长度自增
            }
        }   
    }
    
    /**
     * 获取链表的头结点
     * @return
     */
    public Node<T> getHeadNode(){
        return this.headNode;
    }
    /**
     * 判断链表是否为空
     * @return
     */
    public boolean isEmpty() {
        return this.LenOfLinkList == 0;
    }
    
    /**
     * 取得链表长度
     * @return
     */
    public int getLength() {
        return this.LenOfLinkList;
    }
    /**
     * 依次打印链表
     */
    public void showLinkList() {
        Node<T> p = this.headNode;
        System.out.print("链表数据 ： ");
        while(p!=null && p.data != null) {
            System.out.print(p.data+" ");
            p = p.nextNode;
        }
    }
    /**
     * 删除链表中指定节点的元素
     * @param index
     * @return
     */
    public boolean deleteChildByIndex(int index) {
        Node<T> p = this.headNode;
        Node<T> preNode = this.headNode;
        int count=1;
        if(index > this.LenOfLinkList || index<1) { return false; } // 索引超出链表长度或者小于1 直接返回false
        while(p != null && count != index ) {
            preNode = p;
            p = p.nextNode;
            count++;
        }
        preNode.nextNode = p.nextNode; // 丢弃p节点
        return true;
    }
    
    /**
     * 在链表中添加指定下标的元素
     * @param index
     * @param newNode
     * @return
     */
    public boolean addChildByINdex(int index, Node<T> newNode) {
        if(index > this.LenOfLinkList || index<1) { return false; } // 索引超出链表长度或者小于1 直接返回false
        Node<T> p = this.headNode;
        Node<T> preNode = this.headNode;
        int count=1;
        if(index > this.LenOfLinkList || index<1) { return false; } // 索引超出链表长度或者小于1 直接返回false
        while(p != null && count != index ) {
            preNode = p;
            p=p.nextNode;
            count++;
        }
        preNode.nextNode = newNode;
        newNode.nextNode = p;
        return true;
    }
    
    /**
     * 倒序打印链表(此处用的递归，同时可以用栈实现，递归需要注意递归的最大深度)
     * @param node
     */
    public static void showLinkListFromTheEnd(Node<?> node) {
        if(node != null) {
            if(node.nextNode != null) {
                showLinkListFromTheEnd(node.nextNode);
            }
            System.out.print(node.data+" ");
        }
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        Integer[] k = new Integer[] {1,2,3,4,5,6,7,8,9};
        LinkList<Integer> link = new LinkList<Integer>(k);
        link.showLinkList();  // 打印
        link.deleteChildByIndex(5); // 根据序号删除元素
        link.showLinkList(); 
        Node<Integer> newNode = new Node<Integer>(200);
        link.addChildByINdex(5, newNode); // 指定位置添加元素
        link.showLinkList();
        System.out.println();
        System.out.print("链表倒序打印： ");
        LinkList.showLinkListFromTheEnd(link.getHeadNode()); // 倒序打印，需要获取链表的头结点
    }
}