Java单向链表分析总结

一.什么是单向链表？
它由多个节点组成，每个 节点（用于存储数据） 通过next指针相互连接，从而构成了一个线性的表（它与数组的区别就是它可以不具空间连续性）。

在java中一般通过定义节点类和操作类的方式来实现链表

二.JAVA代码的实现：

1.定义节点：

class ListNode{
    private int data;//存储的数据
    private ListNode next;//它存储了下一个节点对象
    
    //构造方法
    public ListNode(int data){
        this.data=data;
    }
    
    public void setData(int data)//设置本节点数据
    {
        this.data=data;
    }
    public int getData()//返回本节点数据
    {
        return data;
    }
    public void setNext(ListNode next)//设置下一个节点对象
    {
        this.next=next;
    }

    public ListNode getNext()//返回下一个节点对象
    {
        return this.next;
    }

}

二.操作方法定义：

class CaoZuo{
    //计算链表节点数并返回
    int ListLength(ListNode headNode){
        int length=0;
        ListNode currentNode=headNode;
        while(currentNode!=null)
        {
            length++;
            currentNode=currentNode.getNext();
        }
        return length;
    }
    
   //插入节点
    ListNode InsertInLinkedList(ListNode headNode,ListNode nodeToInsert,int position)
    {
        if(headNode==null)
        {
            return nodeToInsert;
        }
        int size=ListLength(headNode);
        //判断链表内是否存在此位置
        if(position>size+1||position<1)
        {
            System.out.println("Position of node to insert is invalid.The valid inputs are 1 to"+(size+1));
            return headNode;
        }
        //在链表开头插入
        if(position==1)
        {
            nodeToInsert.setNext(headNode);
            return nodeToInsert;
        }
        //在中间或末尾插入
        else{
            ListNode previousNode=headNode;
            int count=1;
            //找到那个位置
            while(count<position-1)
            {
                previousNode=previousNode.getNext();//获得第position-1位置的节点
                count++;
            }
            
            ListNode currentNode = previousNode.getNext();//获得第position位置的节点
            //插入操作
            nodeToInsert.setNext(currentNode);
            previousNode.setNext(nodeToInsert);
        }
        return headNode;
    }
 //删除节点
    ListNode DeleteNodeFromLinkedList(ListNode headNode,int position)
    {
        int size = ListLength(headNode);
        if(position>size||position<1)
        {
            System.out.println("Position of node to delete is invalid. The valid inputs are 1 to"+size);
            return headNode;
        }

        if(position==1)//删除表头
        {
            ListNode currentNode = headNode.getNext();
            headNode = null;
            return currentNode;
        }
        //删除中间或结尾节点
        else{
            ListNode previousNode=headNode;
            int count =1;
            while(count<position)
            {
                previousNode = previousNode.getNext();//获得目标节点
                count++;
            }
            //删除目标节点
            ListNode currentNode = previousNode.getNext();
            previousNode.setNext(currentNode.getNext());
            currentNode=null;
        }
        return headNode;

    }


//遍历链表
    void Check(ListNode headNode)
    {
        ListNode check=headNode;
        for(;;)
        {
            System.out.println(check.getData());
            check=check.getNext();
            if(check==null)
                break;
        }
    }

}

弄懂了单向链表，双向链表和循环链表无非是在此基础上的改变：

1.双向链表就是在节点类里多加了一个存储上一结点对象的指针。我们可以用它来逆向操作。
2.循环节点就是将最后的结束条件改为了开始节点。

学习总结自《数据结构与算法经典问题解析》–Narasimha Karumanchi