Java数据结构与算法:链表

一、单链表介绍和基本布局:

1.链表(Linked List)介绍:

链表是有序的列表，其在内存中的存储如下:

(1)链表是以节点的方式来存储;

(2)每个节点包含data域和next域,其中next域指向下一个节点；

(3)链表的各个节点不一定是连续存储的;

(4)链表分为带头节点的链表和不带头节点的链表，根据实际的需求确定 

2.单链表实现

(1)head节点:不存放具体数据，作用就是表示单链表的头

(2)实现步骤:

a.先创建一个head头节点，作用就是表示单链表的头

b.每添加一个节点，就直接加入到 链表的最后

c.通过一个辅助变量帮助遍历整个链表

(3)代码实现:

class Node{
    public int no;
    public String name;
    public String nickName;
    public Node next;
    public Node(int no,String name,String nickName){
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }
}
class SingleLinkedList{
    先初始化一个头节点,不存放具体数据
    private Node head = new Node(0,"","");
    添加节点到单向链表中,当不考虑编号顺序时:
    首先需要找到当前链表的最后节点,并将这个节点的next指向新的节点
    public void add(Node node){
        Node temp = head;
        while(true){
            if(temp.next==null){
                break;
            }
            temp = temp.next;
        }
        temp.next = node;
    }
    public void list(){
        if(head.next==null){
            System.out.println("NULL");
            return;
        }
        Node temp = head.next;
        while(true){
            if(temp==null){
                break;
            }            
            System.out.println(temp);
            temp = temp.next;
        }
    }
    按照顺序添加:
    public void addByOrder(Node node){
       由于头节点不能动，因此仍然通过一个辅助变量帮助找到添加位置
       temp是位于添加位置的前一个节点
       Node temp = head;
       boolean flag = false;判断是否能够插入
       遍历,寻找合适的插入位置
       while(true){
        if(temp.next==null){
            break;
        }
        if(temp.next.no>node.no){
            break;
        }
        if(temp.next.no==node.no){
            flag = true;
            break;
        }
        temp = temp.next;
       }
       if(flag){
        System.out.println("不能加入");
       }else{
         node.next = temp.next;
         temp.next = node;
       }
    }
    根据编号no修改节点中的信息
    public void update(Node newNode){
        if(head.next==null){
            System.out.println("链表为空");
            return;
        }
        Node temp = head.next;
        boolean flag = true;
        while(true){
            if(temp==null){
                break;
            }
            if(temp.no==newNode.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
       if(flag){
          temp.name = newNode.name;
          temp.nickName = newNode.nickName;
       }else{
        System.out.println("Not Found");
       }
    }
    删除指定的节点
    head不动,找到需要删除的节点的前一个节点temp
    比较条件是temp.next.no和需要比较的节点的no
    找到后令temp.next = temp.next.next即可删除节点;
    public void delete(int no){
        Node temp = head;
        boolean flag = false;
        while(true){
        if(temp.next==null){
            break;
        }
        if(temp.next.no == no){
          flag = true;
          break;
        }
        temp = temp.next;
        }
        if(flag){
          temp.next = temp.next.next;
        }
    }
}

(4)单向链表存在的问题:

a.单向链表查找的方向只能是一个方向，而双向链表可以向前或者向后查找;

b.单向链表不能自我删除，需要靠辅助节点，而双向链表则可以自我删除;

3.双向链表

(1)遍历:遍历方向可以和单链表相同，可以向前也可以向后查找

(2)添加:默认添加到双向链表的最后;先找到双向链表的最后节点;令temp.next为新节点,而令新节点的pre为temp节点

(3)修改:同单向链表

(4)删除:因为是双向链表，因此可以实现自我删除某个节点;首先直接找到需要删除的这个节点，记作temp;令temp.pre.next = temp.next以及temp.next.pre = temp.pre即可删除掉指定的节点

(5)代码实现:

class Node{
    public int no;
    public String name;
    public String nickName;
    public Node next;
    public Node pre;
    public Node(int no,String name,String nickName){
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }
}
class DoubleLinkedList{
    private Node head = new Node();
    public void list(){
        if(head.next==null){
            System.out.println("NULL");
            return;
        }
        Node temp = head.next;
        while(true){
            if(temp==null){
                break;
            }            
            System.out.println(temp);
            temp = temp.next;
        }
    }
    public void add(Node node){
        Node temp = head;
        while(true){
            if(temp.next==null){
                break;
            }
            temp = temp.next;
        }
        temp.next = node;
        node.pre = temp;
    }
    public void update(Node newNode){
        if(head.next==null){
            System.out.println("链表为空");
            return;
        }
        Node temp = head.next;
        boolean flag = true;
        while(true){
            if(temp==null){
                break;
            }
            if(temp.no==newNode.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
       if(flag){
          temp.name = newNode.name;
          temp.nickName = newNode.nickName;
       }else{
        System.out.println("Not Found");
       }
    }
    public void delete(int no){
        Node temp = head.next;
        boolean flag = false;
        while(true){
        if(temp==null){
            break;
        }
        if(temp.no == no){
          flag = true;
          break;
        }
        temp = temp.next;
        }
        if(flag){
          temp.pre.next = temp.next;
          需要判断删除的是否是最后一个节点
          如果是最后一个节点,则不需要处理其next.pre
          if(temp.next!=null)
              {
                temp.next.pre = temp.pre;
              }
        }else{
            System.out.println("Not Found");
        }
    }
}