《玩转数据结构》--链表笔记

慕课网《玩转数据结构》–链表

在线性数据结构中，如：

• 动态数组 -----|
• 栈 -----|---------->都在底层依托静态数组：靠resize解决固定容量问题
• 队列 -----|
• 链表 -------------------->真正动态的数据数据结构

为什么链表很重要？

1. 链表为真正动态的数据结构
2. 最简单的动态数据结构
3. 更深入的理解引用（或者指针）
4. 更深入理解递归
5. 辅助组成其他数据结构

链表Linked List

• 数据储存在“节点”（Node）中

  class Node{
  	E e;
  	Node next;
  }
  

• 优点：真正的动态，不需要处理固定容量的问题

• 缺点：丧失了随机访问的能力

数组与链表的对比

数组：

1. 数组最要用在索引有语义的情况，如score[2];
2. 最大的优点：支持快速查询

链表：

1. 链表不适合用于索引有语义的情况
2. 最大的有点：动态

链表的代码实现：

public class LinkedList<E>{
    //链表的内部类：节点
    private class Node{
        public E e;
        public Node next;
        
        //带参构造函数，为后续节点的移动作准备
        public Node (E e,Node next){
            this.e = e;
      		this.next = next;
        }
     
        public Node(E e){
        	this(e,null);
        }
       
        public Node(){
            this(null,null);
        }
        
        @Override
        public String toString(){
            return e.toString();
        }
    }
    
    
    //链表的属性
    //链表的头节点，可看作下标为“-1”的节点，方便后期增加操作
   	private Node dummyHead;
    //链表的长度，方便维护链表
    private int size;
    
    public LinkedList(){
        dummyHead = new Node();
        size = 0;
    }   
    
    // 获取链表中的元素个数
    public int getSize(){
        return size;
    }

    // 返回链表是否为空
    public boolean isEmpty(){
        return size == 0;
    }
    
    //在链表的index（0-based）的位置添加新的元素e
    //在链表中不是一个常用的操作，因为链表不会常用下标进行操作，当练习用：
    public void add(int index,E e){
        //维护下标的合法性，当插入节点的索引小于0或者超过size长度，报错：
        if(index < 0 || index > size){
            throw new IllegalArgumentException("Add failed. Illegal index.")
        }
        Node prev = dummyHead;//在链表的“-1”头节点开始遍历
        for(int i = 0 ; i < index ; i++){
            //遍历（index-1-(-1)）次就到了需要添加的位置的前一个
            //prev为所插入节点的前一个，prev.next即为所要插入的节点
            prev = prev.next;
        }
        // Node node = new Node(e); //new一个节点，存储所要插入的数据
        // node.next = prev.next;   //找到插入节点的下一位的指向，并赋值给node的下一位
        // prev.next = node;       //插入节点的下一位指向node（见图2）
        
        //上面3行代码可以压缩为下面一句：
        prev.next = new Node(e,prev.next);
        size ++;//维护链表的长度
    }
   
     // 在链表头添加新的元素e
    public void addFirst(E e){
        add(0, e);
    }

    // 在链表末尾添加新的元素e
    public void addLast(E e){
        add(size, e);
    }
    
    // 获得链表的第index(0-based)个位置的元素
    // 在链表中不是一个常用的操作，练习用
    public E get(int index){
        if(index < 0 || index >= size){
          throw new IllegalArgumentException("Get failed. Illegal index.");   
        }
        Node cur = dummyHead.next; //从链表为0的节点开始遍历
        for(int i = 0 ; i < index ; i++){
        //相当于从0开始遍历，遍历index次就到了所要获取的上一位，next则获取到想要的节点
            cur = cur.next;
        }
        return cur.e;
    }
    
     // 获得链表的第一个元素
    public E getFirst(){
        return get(0);
    }

    // 获得链表的最后一个元素
    public E getLast(){
        return get(size - 1);
    }

    // 修改链表的第index(0-based)个位置的元素为e
    // 在链表中不是一个常用的操作，练习用：）
    // 思路与get方法类似，最后需要对cur.e 赋值。
    public void set(int index, E e){
        if(index < 0 || index >= size){
          throw new IllegalArgumentException("Set failed. Illegal index.");   
        }
        Node cur = dummyHead.next;
        for(int i = 0 ; i < index ; i ++){
           cur = cur.next; 
        } 
        cur.e = e;
    }
    
    // 查找链表中是否有元素e
    public boolean contains(E e){
        Node cur = dummyHead.next;
        //从下标为0的节点开始遍历，如果节点的下一个节点不为零就继续遍历
        while(cur != null){
            if(cur.e.equals(e)){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }
    
    // 从链表中删除index(0-based)位置的元素, 返回删除的元素
    // 在链表中不是一个常用的操作，练习用：）
    public E remove(int index){
        if(index < 0 || index >= size){
           throw new IllegalArgumentException("Remove failed. Index is illegal."); 
        }
        //从-1开始
        Node prev = dummyHead;
        for(int i = 0 ; i < index ; i ++){
             prev = prev.next;
        }
        Node retNode = prev.next;
        prev.next = retNode.next;
        retNode.next = null;
        size --;

        return retNode.e;
    }

    // 从链表中删除第一个元素, 返回删除的元素
    public E removeFirst(){
        return remove(0);
    }

    // 从链表中删除最后一个元素, 返回删除的元素
    public E removeLast(){
        return remove(size - 1);
    }

    // 从链表中删除元素e
    public void removeElement(E e){

        Node prev = dummyHead;
        while(prev.next != null){
            if(prev.next.e.equals(e))
                break;
            prev = prev.next;
        }

        if(prev.next != null){
            Node delNode = prev.next;
            prev.next = delNode.next;
            delNode.next = null;
            size --;
        }
    }
    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        
        Node cur = dummyHead.next;
        while(cur != null){
            res.append(cur + "->");
            cur = cur.next;
        }
        res.append("NULL");

        return res.toString();
    }

}

删除节点的步骤：

新增节点的步骤：