【Java】数据结构——单链表的实现

链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑是通过链表中的引用链接次序实现的。

顺序表：物理上和逻辑上都连续。

链表：物理上不一定连续，逻辑上一定是连续的。

数据结构中：

 

先定义一个接口

public interface ILinked {
    //头插法
    void addFirst(int data);
    //尾插法
    void addLast(int data);
    //任意位置插入,第一个数据节点为0号下标
    boolean addindex(int index,int data);
    //查找是否包含关键字key是否在单链表当中
    boolean contains(int key);
    //删除第一次出现关键字为key的节点
    int remove(int key);
    //删除所有值为key的节点
    void removeAllKey(int key);
    //得到单链表的长度
    int getLength();
    void display();
    void clear();
}

实现：

*@Author:
 *@Date: 
 *@Description:单链表的实现
 */
public class MySingleListImpl implements ILinked {
    class Node {
        private int data;
        public Node next;

        public Node(int data) {
            this.data = data;
            this.next = null;
        }

        public int getData() {
            return data;
        }

        public Node getNext() {
            return next;
        }
    }

    //head属于单链表的属性
    private Node head;

    //构造函数，对头结点进行初始化
    public MySingleListImpl() {
        this.head = null;
    }

    public Node getHead() {
        return head;
    }

    //头插法
    @Override
    public void addFirst(int data) {
        Node node = new Node(data);
        if (this.head == null) {
            this.head = node;
        } else {
            node.next = this.head;
            this.head = node;
        }
    }

    //尾插法
    @Override
    public void addLast(int data) {
        Node cur = this.head;
        Node node = new Node(data);
        if (cur == null) {
            this.head = node;
        } else {
            while (cur.next != null) {
                cur = cur.next;
            }
            cur.next = node;
        }
    }

    @Override
    public boolean addindex(int index, int data) {
        if (index < 0 || index > getLength()) {//合法性进行判断
            throw new UnsupportedOperationException("插入坐标不合法");
        }
        Node node = new Node(data);
        if (index == 0) {
            addFirst(data);
            return true;
        } else {
            Node cur = this.head;
            int count = 0;
            while (count < index - 1) {
                cur = cur.next;
                count++;
            }
            //跳出循环表示当前cur所指的结点是需要插入位置的结点
            node.next = cur.next;
            cur.next = node;
            return true;
        }
    }
    public boolean contains(int key) {
        if (this.head == null) {
            throw new UnsupportedOperationException("该链表为空，不存在该元素key");
        }
        Node cur = this.head;
        while (cur != null) {
            if (cur.data == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

    @Override
    public int remove(int key) {
        int oldData = 0;
        Node pre = this.head;
        if (this.head == null) {
            throw new UnsupportedOperationException("链表为空，不存在指定元素key");
        }
        if (this.head != null && this.head.data == key) {
            oldData = this.head.data;
            this.head = this.head.next;
            return oldData;
        }
        while (pre.next.data == key) {
            if (pre.next.data == key) {
                oldData = pre.next.data;
                pre.next = pre.next.next;
                return oldData;
            } else {
                pre = pre.next;
            }
        }
        throw new UnsupportedOperationException("没有找到该元素");
    }
    @Override
    public void removeAllKey(int key) {
        if(this.head == null){
            return;
        }
        Node pre = this.head;
        Node cur = this.head.next;
        while(cur != null){
            if(cur.data == key){
                pre.next = cur.next;
                cur = cur.next;
            }else {
                pre = cur;
                cur = cur.next;
            }
        }
        if(this.head.data == key){
            this.head = this.head.next;
        }
    }

    @Override
    public int getLength() {
        int num = 0;
        Node cur = this.head;
        while (cur != null){
            num++;
            cur = cur.next;
        }
        return num;
    }

    @Override
    public void display() {
        Node cur = this.head;
        //如果cur为空，那么单链表为空，就不能打印
        while(cur != null){
            System.out.println(cur.data + " ");
            cur = cur.next;
        }
        System.out.println();
    }

    @Override
    public void clear() {
        while (this.head != null){
            Node cur = this.head.next;
            this.head = cur;
        }
    }
}