Java基础——链表的添加、移除、反转

1 链表

链表：是由节点组成的。

节点：是由数据域+引用域组成。

节点与节点之间：引用域进行链接。

2 链表实现

2.1 定义节点类

• 节点类
• 链表：是有节点链接起来的
• 节点：有数据域（存储数据，类型不定）+引用域（存储下一个节点，用于节点链接）

package com.java8.mylinkedlist;

/**
 * 节点类
 * 链表：是有节点链接起来的
 * 节点：有数据域（存储数据，类型不定）+引用域（存储下一个节点，用于节点链接）
 */
public class Node {
    private Object data;
    private Node next;

    //无参构造方法
    public Node(){

    }
    //有参构造，初始化的时候设置root的data为null
    public Node(Object data){
        this.data = data;
    }

    //获取数据，使用数据时需要
    public Object getData() {
        return data;
    }
    //设置数据，添加add时需要
    public void setData(Object data) {
        this.data = data;
    }

    //获取下一个节点，查找get需要
    public Node getNext() {
        return next;
    }

    //设置下一个节点，添加add时候需要
    public void setNext(Node next) {
        this.next = next;
    }

}

 

2.2 实现链表类

• 链表类
• 链表：包括头结点root + n个数据节点node（包括尾部节点last）

链表类包括以下功能：

• add(Object data)：添加node到链表，参数为data

头插法 add_head()：每次插入node放在root后面，链表最前面

尾插法 add()：每次插入node放在链表最后

• size()：返回链表大小

• get(int index)：返回第index个链表的data

• remove(int index)：移除第index个元素

• reverse(LinkedList linkedList)：反转链表

package com.java8.mylinkedlist;

/**
 * 链表类
 * 链表：包括头结点root + n个数据节点node（包括尾部节点last）
 */
public class LinkedList {
    //链表的长度
    private int size = 0;
    //链表的头结点，内容为null
    private Node root = new Node(null);
    //链表的尾部：尾插法
    private Node last = root;

    //构造方法，初始化链表
    public LinkedList() {
    }

    /**
     * 1.2、add()方法:
     * 尾差法:添加新节点到链表的末尾
     * @param data：添加的数据
     */
    public void add(Object data) {
        //创建本node对象的时候初始化数据:data
        Node node = new Node(data);

        //1 尾差法:添加到链表的末尾
        //设置尾部last的下一个为：node
        last.setNext(node);
        //更新链表尾部last
        last = node;
        //size增加
        size++;

    }

    /**
     * 1.3、add_head()方法:
     * 头插法：添加新节点到头节点后面
     * @param data：添加的数据
     */
    public void add_head(Object data) {
        //创建本node对象的时候初始化数据:data
        Node node = new Node(data);
        //2 头插法：添加到头节点后面
        //设置该node的下一个为：root的下一个
        node.setNext(root.getNext());
        //设置root的下一个为：本node
        root.setNext(node);
        //size增加
        size++;
    }

    /**
     * 2、获取链表大小
     *
     * @return ：链表长度
     */
    public int size() {
        return size;
    }

    /**
     * 3、获取链表第index的数据data
     *
     * @param index ：要获取的第i个链表
     * @return :第index的个链表的数据内容
     */
    public Object get(int index) {

        Node node = root.getNext();

        if (index < 0 || index > size) {
            return null;
        }

        for (int i = 0; i < index; i++) {
            node = node.getNext();
        }

        return node.getData();
    }

    /**
     * 4、移除第index的节点node
     *
     * @param index ：第i个
     * @return
     */
    public Object remove(int index) {
        Node node = root.getNext();
        if (index < 0 || index > size) {
            return 0;
        }
        //1 若要移除的index为第一个node，index为0，不存在index-1，则单独设置
        if (index == 0) {
            //setNext链接上一个和下一个 ：上一个为root,下一个为node.getNext()
            root.setNext(node.getNext());
            //清除该节点的引用域为null：next
            node.setNext(null);
            //大小－1
            size--;
        }
        //2 移除的index不为0
        else {
            //2.1 获取三个节点：上一个node、这个removenode、下一个nextnode
            // 获取要移除node的上一个node
            for (int i = 0; i < index - 1; i++) {
                node = node.getNext();
            }
            // 获取要移除的node
            Node removenode = node.getNext();
            // 获取要移除的下一个node
            Node nextnode = removenode.getNext();

            //2.2 setNext链接上一个和下一个：上一个为node，下一个为nextnode
            node.setNext(nextnode);
            //2.3 清除该node的引用域为null：next
            removenode.setNext(null);
            //2.4 大小－1
            size--;
        }
        return 0;
    }

    /**
     * 5、reverse 反转链表
     * 利用头插法，直接可以反转链表
     * @param linkedList 原链表
     * @return 翻转后的链表
     */
    public LinkedList reverse(LinkedList linkedList){

        LinkedList rlinkedList = new LinkedList();
        Node node = linkedList.root.getNext();
        for (int i = 0; i < linkedList.size(); i++) {
            rlinkedList.add_head(node.getData());
            node = node.getNext();
        }
        return rlinkedList;
    }
}

 

2.3 测试代码 Manage类：

package com.java8.mylinkedlist;

import java.util.Random;

public class Manage {
    public static void main(String[] args) {

        //创建链表对象
        LinkedList linkedList = new LinkedList();
        //随机给出大小:1-20
        int size = new Random().nextInt(20)+1;

        //1.add
        for (int i = 0; i < size; i++) {
            linkedList.add((char)(97+i));
        }

        //2.size
        System.out.println("1 创建 —————————————————————————————");
        System.out.println("链表的size为："+linkedList.size());
        //3.get
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println("第i个数据为："+linkedList.get(i));
        }

        //4.remove
        //随机给出删除数据index：1-size
        System.out.println("2 移除 —————————————————————————————");
        int removeindex = new Random().nextInt(linkedList.size()-1)+1;
        System.out.println("移除的index为："+removeindex);
        System.out.println("移除的data为："+linkedList.get(removeindex));
        linkedList.remove(removeindex);
        System.out.println("移除后链表的size为："+linkedList.size());
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println("移除后第i个数据为："+linkedList.get(i));
        }
        //5.reverse
        System.out.println("3 翻转 —————————————————————————————");
        LinkedList rlinkedList = linkedList.reverse(linkedList);
        System.out.println("翻转后链表的size为："+rlinkedList.size());
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println("翻转后第i个数据为："+rlinkedList.get(i));
        }

    }
}

输出结果：
1 创建 —————————————————————————————
链表的size为：7
第i个数据为：a
第i个数据为：b
第i个数据为：c
第i个数据为：d
第i个数据为：e
第i个数据为：f
第i个数据为：g
2 移除 —————————————————————————————
移除的index为：5
移除的data为：f
移除后链表的size为：6
移除后第i个数据为：a
移除后第i个数据为：b
移除后第i个数据为：c
移除后第i个数据为：d
移除后第i个数据为：e
移除后第i个数据为：g
3 翻转 —————————————————————————————
翻转后链表的size为：6
翻转后第i个数据为：g
翻转后第i个数据为：e
翻转后第i个数据为：d
翻转后第i个数据为：c
翻转后第i个数据为：b
翻转后第i个数据为：a