数据结构-链表 JAVA语言实现

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/z740852294/article/details/77369439

数据结构-链表 JAVA语言实现

作为一名Android程序员，开始学习数据结构和算法，用JAVA语言写写自己对链表的看法和代码上的实现，如果有问题，麻烦指出，互相学习。

目录

• 单向链表
• 双向链表
• 循环链表

---

1、单向链表

单向链表包含多个结点，每个结点都有一个next指向下一个结点，直到最后一个结点的next指向为null，链表结束。

单向链表结点实体类：

/**
 * 单向链表
 */
public class ListNode {

    private int data;  //结点的数据
    private ListNode next;   //指向下一个结点

    public ListNode(int data) {
        this.data = data;
    }
    public int getData() {
        return data;
    }
    public void setData(int data) {
        this.data = data;
    }
    public ListNode getNext() {
        return next;
    }
    public void setNext(ListNode next) {
        this.next = next;
    }
}

1.1 遍历链表

循环遍历每个结点，知道结点的next为null时，当前结点为尾结点。

    /**
     * 遍历链表，获取长度
     * @param headNode
     * @return 链表长度
     */
    public int listLength(ListNode headNode){
        int count = 0;
        ListNode currentNode = headNode;
        while(currentNode != null){
            count ++;
            currentNode = currentNode.getNext();
        }
        return count ;
    }

1.2 插入元素

插入元素包括三种情况：

• 插入到头结点前
• 插入到链表中间位置

• 插入到尾结点

  （1）插入到头结点只需要将插入的结点的next指向当前头结点，返回插入结点即可。
  （2）插入到中间或者尾结点，遍历结点直到插入位置的前一个节点，将next指向插入结点，再将插入结点的next指向后一元素(如果插入的结点在最后，后以节点为null)。

 /**
     * 插入结点  可以为头 中 尾插入
     * @param headNode 当前头结点
     * @param insertNode 插入结点
     * @param position 插入位置
     * @return 返回插入后的头结点
     */
    public ListNode insertNode(ListNode headNode,ListNode insertNode,int position){
        //当当前链表为空，新链表直接为插入的链表
        if(headNode == null){
            return insertNode;
        }
        //获取长度
        int size = listLength(headNode);
        if(position > size + 1 || position < 1){
            //插入位置不合法
            System.out.println("插入位置不合法！");
            return headNode;
        }
        //链表开头插入
        if(position == 1){
            insertNode.setNext(headNode);
            headNode = insertNode;

        }else{
            ListNode previousNode = headNode;
            int count = 1;
            while (count < position -1){
                previousNode = previousNode.getNext();
                count++;
            }
            insertNode.setNext(previousNode.getNext());
            previousNode.setNext(insertNode);
        }
        return headNode;
    }

1.3 删除元素

删除元素同样区别删除位置：头、中、尾
（1）删除头结点：将头结点next设为null，下一个结点即为新的头结点
（2）删除中间或尾部结点，遍历链表直到删除的位置的前一个结点，同时拿到删除位置的后一个结点，将前一个结点的next指向后一个节点。

/**
     * 删除某个结点
     * @param headNode 头结点
     * @param position 删除位置
     * @return 返回头结点
     */
    public ListNode deleteNode(ListNode headNode,int position){
        //当前链表为空，
        if(headNode == null){
            System.out.print("当前链表为空，不能删除！");
            return null;
        }
        //获取长度
        int size = listLength(headNode);
        if(position > size  || position < 1){
            //删除位置不合法
            System.out.println("删除位置不合法！");
            return headNode;
        }
        if (position == 1){
            // 删除头结点
            ListNode currentNode = headNode.getNext();
            headNode = null;
            return currentNode;
        }else {
            ListNode previousNode = headNode;
            int count = 1;
            while (count < position - 1){
                previousNode = previousNode.getNext();
                count++;
            }
            //currentNode为删除的那个结点
            ListNode currentNode = previousNode.getNext();
            previousNode.setNext(currentNode.getNext());
            currentNode = null;
        }
        return headNode;
    }

2、双向链表

双向链表顾名思义就是有两个方向，多一个前驱结点。
双向链表结点的实体类：

/**
 * 双向链表
 */
public class DLLNode {
    private int data;
    private DLLNode next;
    private DLLNode previous;

    public DLLNode(int data, DLLNode newxt, DLLNode previous) {
        this.data = data;
        this.next = newxt;
        this.previous = previous;
    }

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

    public DLLNode getNext() {
        return next;
    }

    public void setNext(DLLNode next) {
        this.next = next;
    }

    public DLLNode getPrevious() {
        return previous;
    }

    public void setPrevious(DLLNode previous) {
        this.previous = previous;
    }
}

2.1 遍历元素

与单向链表类似，直接上代码：

 /**
     * 获取双向链表长度
     * @param headNode 头结点
     * @return
     */
    public int getDllLength(DLLNode headNode) {
        int count = 0;
        DLLNode current = headNode;
        while (current != null) {
            current = current.getNext();
            count++;
        }
        return count;
    }

2.2 插入元素

与单向链表相似，但是要修改插入元素指向的前驱结点。

/**
     * 插入结点
     * @param headNode 当前头结点
     * @param insertNode 插入的结点
     * @param position 插入位置
     * @return 插入后的头结点
     */
    public DLLNode insertDllNode(DLLNode headNode , DLLNode insertNode, int position){
        if (headNode == null){
            return insertNode;
        }
        int size = getDllLength(headNode);
        if(position < 1 || position > size + 1){
            System.out.println("插入位置有误");
            return headNode;
        }
        //插入到首位
        if (position == 1){

            insertNode.setNext(headNode);
            headNode.setPrevious(insertNode);
            return insertNode;
        }else {
            DLLNode previousNode = headNode;
            int count = 1;
            while (count < position - 1){
                previousNode = previousNode.getNext();
                count ++;
            }
            DLLNode currentNode = previousNode.getNext();
            if(previousNode.getNext() != null){
                //插入的位置在末尾
                currentNode.setPrevious(insertNode);
            }
            insertNode.setNext(currentNode);
            previousNode.setNext(insertNode);
            insertNode.setPrevious(previousNode);
        }

        return headNode;
    }

2.3 删除元素

/**
     * 删除结点
     * @param headNode 头结点
     * @param position 插入位置
     * @return 新链表的头结点
     */
    public DLLNode deleteNode(DLLNode headNode , int position){
        if(headNode == null){
            System.out.println("当前链表为空，不能进行删除操作!");
            return null;
        }
        int size = getDllLength(headNode);
        if(position < 1 || position > size){
            System.out.println("删除位置有误");
            return headNode;
        }
        if(position == 1){
            DLLNode currentNode = headNode.getNext();
            currentNode.setPrevious(null);
            headNode = null;
            return currentNode;
        }else {
            DLLNode currentNode = headNode;
            int count = 1;
            while (count < position){
                currentNode  = currentNode.getNext();
                count++;
            }
            DLLNode previousNode = currentNode.getPrevious();
            DLLNode nextNode = currentNode.getNext();
            previousNode.setNext(nextNode);
            if(nextNode != null){
                nextNode.setPrevious(previousNode);
            }
            currentNode = null;
        }
        return headNode;
    }

3、循环链表

循环链表与单向、双向链表的很大差别是没有null值表示结束，不做判断的话，一直循环下去。
循环链表结点实体类：

/**
 * 循环链表
 */
public class CLLNode {
    private int data;
    private CLLNode next;

    public CLLNode(int data) {
        this.data = data;
    }

    public CLLNode(int data, CLLNode next) {
        this.data = data;
        this.next = next;
    }

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

    public CLLNode getNext() {
        return next;
    }

    public void setNext(CLLNode next) {
        this.next = next;
    }
}

3.1 遍历链表

通过判断循环后的结点是否为头结点还做出结束循环操作。

    /**
     * 循环链表长度
     *
     * @param headNode 头结点
     * @return 长度
     */

    public int getListLenth(CLLNode headNode) {
        int count = 0;
        CLLNode currentNode = headNode;
        while (currentNode != null) {
            currentNode = currentNode.getNext();
            count++;
            if (currentNode == headNode) {
                break;
            }

        }
        return count;
    }

3.2 插入元素

循环链表插入与单向链表类似，注意将尾结点指向头结点即可。

    /**
     * 尾部插入
     *
     * @param headNode   头结点
     * @param insertNode 插入结点
     * @return 返回头结点
     */
    public CLLNode insertEndNode(CLLNode headNode, CLLNode insertNode) {
        CLLNode currentNode = headNode;
        while (currentNode.getNext() != headNode) {
            currentNode = currentNode.getNext();
        }
        currentNode.setNext(insertNode);
        insertNode.setNext(headNode);
        return headNode;
    }

    /**
     * 头部插入
     * @param headNode   头结点
     * @param insertNode 插入结点
     * @return 返回头结点
     */
    public CLLNode insertStartNode(CLLNode headNode, CLLNode insertNode) {
        CLLNode currentNode;
        currentNode = headNode;
        while (currentNode.getNext() != headNode) {
            currentNode = currentNode.getNext();
        }
        currentNode.setNext(insertNode);
        insertNode.setNext(headNode);

        return insertNode;
    }

3.3 删除元素

    /**
     * 删除头结点
     *
     * @param headNode 头结点
     * @return 新头结点
     */
    public CLLNode deleteStartNode(CLLNode headNode) {
        CLLNode currentNode = headNode;
        while (currentNode.getNext() != headNode) {
            currentNode = currentNode.getNext();
        }
        CLLNode newHeadNode = headNode.getNext();
        currentNode.setNext(newHeadNode);
        return newHeadNode;
    }

    /**
     * 删除尾结点
     *
     * @param headNode 头结点
     * @return 新头结点
     */
    public CLLNode deleteEndNode(CLLNode headNode) {
        CLLNode currentNode = headNode;
        CLLNode lastNode = headNode;
        while (currentNode.getNext() != headNode) {
            lastNode = currentNode;
            currentNode = currentNode.getNext();
        }
        currentNode = null;
        lastNode.setNext(headNode);

        return headNode;
    }

循环链表中部的删除、插入于单向链表相似。

完整代码：
http://download.csdn.net/download/z740852294/9947970