数据结构学习（四）：链表

一、学习内容

今天开始学习链表，主要实现的功能有：

getSize:获得链表大小；

isEmpty：判断链表是否为空；

add(int index,E e)：在索引为index的位置添加元素e;

get(int index)：获得索引为index处的元素；

set(int index,E e)：将索引为index处位置的元素替换为e；

contain(E,e)：判断链表中是否含有元素e；

remove(int index):删除索引为index的元素；

remove(E e):删除链表中的元素e。

二、链表代码：

package IMUHERO;
/**
 * @作者：IMUHERO
 * @时间：2019/3/5
 * @内容：带虚拟头结点的链表的基本功能实现
 */
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=e;
            this.next=null;
        }
        public Node(){
            this(null,null);
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }
    private Node dummyHead;
    private int size;

    //构造方法，新建虚拟头结点，指向null。size=0;
    public LinkedList(){
        size=0;
        dummyHead=new Node();
    }

    public int getSize(){
        return size;
    }

    public boolean isEmpty(){
        return size==0;
    }
    //添加元素
    public void add(int index ,E e){
        Node prev=dummyHead;
        if (index<0||index>size )throw new IllegalArgumentException("index is an illegal input");
        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 an illegal input");
        Node cur =dummyHead.next;
        for (int i=0;i<index;i++){
            cur=cur.next;
        }
        size--;
        return cur.e;
    }

    //设置元素
    public void set(int index,E e){
        if (index<0||index>size )throw new IllegalArgumentException("index is an illegal input");
        Node cur =dummyHead.next;
        for (int i=0;i<index;i++){
            cur=cur.next;
        }
        cur.e=e;
        size++;
    }

    //查询是否含有e元素
    public boolean contain(E e){
        for (Node cur=dummyHead.next;cur!=null;cur=cur.next){
            if (cur.e.equals(e))return true;
        }
        return false;
    }
    //删除索引为index处的元素
    public E remove(int index ){
        if (index<0||index>size )throw new IllegalArgumentException("index is an illegal input");
        Node prev=dummyHead;
        for (int i=0;i<index;i++){
            prev=prev.next;
        }
        Node redel=prev.next;
        prev.next=redel.next;
        redel.next=null;
        size--;
        return redel.e;
    }

    //删除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 redel=prev.next;
            prev.next=redel.next;
            redel.next=null;
            System.out.println(e+"已经被删除");
        }
        else System.out.println("未查询到元素"+e);

    }

    @Override
    public String toString() {
        StringBuilder strb=new StringBuilder();
            Node cur=dummyHead.next;
            while (cur!=null){
                strb.append(cur.e+"->");
                cur=cur.next;
            }
            strb.append("null");
            return strb.toString();
    }
}

三、测试函数

package IMUHERO;

public class Main {

    public static void main(String[] args) {
	// write your code here
        LinkedList<Integer> linkedList=new LinkedList<>();
        for (int i=0;i<10;i++){
            linkedList.addFirst(i);
            System.out.println(linkedList);
        }
        linkedList.add(2,100);
        System.out.println(linkedList);

        System.out.println("链表大小为："+linkedList.getSize());

        linkedList.set(2,200);

        System.out.println("在索引为2的地方替换的数据是："+linkedList.get(2));
        System.out.println(linkedList);
        System.out.println("链表中含有100："+linkedList.contain(100));
        System.out.println("链表中含有200："+linkedList.contain(200));;

        System.out.println("删除索引为9的元素");
        linkedList.remove(9);
        System.out.println("删除后的链表为："+linkedList);

        linkedList.removeElement(8);
        System.out.println("删除后的链表为："+linkedList);
    }
}

四、输出结果：

0->null
1->0->null
2->1->0->null
3->2->1->0->null
4->3->2->1->0->null
5->4->3->2->1->0->null
6->5->4->3->2->1->0->null
7->6->5->4->3->2->1->0->null
8->7->6->5->4->3->2->1->0->null
9->8->7->6->5->4->3->2->1->0->null
9->8->100->7->6->5->4->3->2->1->0->null
链表大小为：11
在索引为2的地方替换的数据是：200
9->8->200->7->6->5->4->3->2->1->0->null
链表中含有100：false
链表中含有200：true
删除索引为9的元素
删除后的链表为：9->8->200->7->6->5->4->3->2->0->null
8已经被删除
删除后的链表为：9->200->7->6->5->4->3->2->0->null

结果符合链表功能要求。

数据结构学习（四）：链表

猜你喜欢