【数据结构】单链表的插入与删除

1.链接存储结构的定义

• 在计算机中用一组任意的存储单元存储线性表的数据元素(这组存储单元可以是连续的,也可以是不连续的).

• 它不要求逻辑上相邻的元素在物理位置上也相邻.因此它没有顺序存储结构所具有的弱点,但也同时失去了顺序表可随机存取的优点.

• 链式存储结构又分为单链表、双链表、循环链表。

2.链式存储结构的特点

• 比顺序存储结构的存储密度小 (每个节点都由数据域和指针域组成，所以相同空间内假设全存满的话顺序比链式存储更多)。

• 逻辑上相邻的节点物理上不必相邻。

• 每个结点是由数据域和指针域组成。

3.单链表的插入与删除

• 插入图解

• 删除图解

• 代码实现

public class SingleLinked {
    private class Node{
        public int getData() {
            return data;
        }

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

        public Node getNext() {
            return next;
        }

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

        private int data;
        private Node next;

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

    private Node head;

    //插入
    public void insert (int data){

        Node node = new Node(data,null);

        if (null == this.head){
            this.head = node;
            return;
        }

        //若插入节点小于头节点，则设置新插入节点为头节点
        if (head.getData() > data){
            node.setNext(this.head);
            this.head = node;
            return;
        }

        //记录头节点位置
        Node p = head;

        //从头节点开始寻找大于data的位置
        while(null != p.getNext()){
            if (p.getNext().getData() > data){
               break;
            }
            //下一个节点
            p = p.getNext();
        }

        //插入节点
        node.setNext(p.getNext());
        p.setNext(node);
    }

    //删除
    public void remove(int data){
        if (null == this.head ){
            System.out.println("链表为空！");
            return;
        }

        if (this.head.getData() == data){
            this.head = this.head.getNext();
            return;
        }

        Node p = this.head;

        while(null != p.getNext()){
            if (p.getNext().getData() == data){
                break;
            }
            p = p.getNext();
        }

        if (null != p.getNext()){
            p.setNext(p.getNext().getNext());
            print();
        }else{
            System.out.println(data + " 不存在！");
        }

    }

    //输出链表元素
    public void print(){
        if (null == this.head){
            return;
        }
        Node p = this.head;
        while(null != p){
            System.out.println(p.getData()+"  ");
            p = p.getNext();
        }
    }

    //链表逆序
    public void reverseLinkList() {
        if (head == null || head.getNext() == null) {
            return ;
        } else {
            Node temp = null;
            Node p = head;
            while (head != null) {
                p = head.getNext();
                head.setNext(temp);
                temp = head;
                head = p;
            }
            head = temp;
        }
    }

    //判断是否为循环链表
    public boolean isCircle(){
        Node fast = head;
        Node slow = head;
        if (head == null || head.getNext() == null){
            return false;
        }
        while(null != head){
            fast = fast.getNext().getNext();
            slow = slow.getNext();
            if (fast == slow){
                break;
            }else if (fast == null || fast.getNext() == null){
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        SingleLinked list = new SingleLinked();
        list.insert(5);
        list.insert(3);
        list.insert(1);
        list.insert(4);
        list.print();
        System.out.println("删除后------");
        list.remove(3);
        list.reverseLinkList();
        System.out.println("逆序-------");
        list.print();
        System.out.println("是否有环---"+list.isCircle());

    }
}

输出结果

1  
3  
4  
5  
删除后------
1  
4  
5  
逆序-------
5  
4  
1  
是否有环---false

4.链式存储结构的优缺点

• 优点
  插入、删除开销小(不必移动节点，只要改变节点中的指针)。

• 缺点
  查找结点时链式存储要比顺序存储慢。

本人才疏学浅，若有错，请指出
谢谢 ！