数据结构及算法之链表讲解

1,普通实现方式

package com.dream21th.algorithmicdatastructure.linkedlist;

/**
 * @Auther: hp
 * @Date: 2019/9/13 16:07
 * @Description:
 */
public class LinkList<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();
        }
    }

    private Node head;
    private int size;

    public LinkList() {
        this.head=null;
        size=0;
    }

    public int getSize(){
        return size;
    }

    public boolean isEmpty(){
        return size==0;
    }

    public void addFirst(E e){
       /* Node node = new Node(e);
        node.next=head;
        head=node;*/
        head = new Node(e, head);
        size++;
    }

    public void add(int index,E e){
        if(index<0 || index>size){
            throw new IllegalArgumentException("index is illegal");
        }

        if(index==0){
            addFirst(e);
        }else {

            Node prev=head;
            for(int i=0;i<index-1;i++){
                prev=prev.next;
            }

            prev.next=new Node(e,prev.next);
        }
    }

    public void addLast(E e){
        add(size,e);
    }
}

2,带虚拟头节点实现方式

package com.dream21th.algorithmicdatastructure.linkedlist;

/**
 * @Auther: hp
 * @Date: 2019/9/13 16:07
 * @Description:
 */
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();
        }
    }

    /**
     * 虚拟头节点
     */
    private Node dummyHead;
    private int size;

    public LinkedList() {
        this.dummyHead=new Node(null,null);
        size=0;
    }

    public int getSize(){
        return size;
    }

    public boolean isEmpty(){
        return size==0;
    }



    public void add(int index,E e){
        if(index<0 || index>size){
            throw new IllegalArgumentException("index is illegal");
        }

        Node prev=dummyHead;
        for(int i=0;i<index;i++){
            prev=prev.next;
        }

        prev.next=new Node(e,prev.next);
        size++;

    }

    public void addFirst(E e){
      add(0,e);
    }
    public void addLast(E e){
        add(size,e);
    }

    public E get(int index){
        if(index<0 || index>=size){
            throw new IllegalArgumentException("index is illegal");
        }
        Node cur=dummyHead.next;

        for(int i=0;i<index;i++){
            cur=cur.next;
        }
        return cur.e;
    }

    public E getFirst(){
        return get(0);
    }

    public E getLast(){
        return get(size-1);
    }

    public boolean contains(E e){
        for(Node cur=dummyHead.next;cur!=null;cur=cur.next){
            if(cur.e.equals(e)){
                return true;
            }
        }
        return false;
    }

    public void set(int index,E e){
        if(index<0 || index>=size){
            throw new IllegalArgumentException("index is illegal");
        }
        Node cur=dummyHead.next;

        for(int i=0;i<index;i++){
            cur=cur.next;
        }
        cur.e=e;
    }

    public E remove(int index){
        if(index<0 || index>=size){
            throw new IllegalArgumentException("index is illegal");
        }
        Node prev=dummyHead;
        for(int i=0;i<index;i++){
            prev=prev.next;
        }
        Node currentNode = prev.next;
        prev.next=currentNode.next;
        currentNode.next=null;
        size--;
        return currentNode.e;
    }

    public E removeFirst(){
        return remove(0);
    }

    public E removeLast(){
        return remove(size-1);
    }
    @Override
    public String toString() {
        StringBuilder builder=new StringBuilder();
        Node cur = dummyHead.next;
        while (cur!=null){
            builder.append(cur+"->");
            cur=cur.next;
        }
        builder.append("NULL");
        return builder.toString();
    }
}

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

dream21st

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值