LinkedList与链表

LinkedList的底层是双向链表结构(链表后面介绍)，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。

 1. LinkedList实现了List接口
2. LinkedList的底层使用了双向链表
3. LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问
4. LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O(1)

LinkList的构造

public static void main(String[] args) {
// 构造一个空的LinkedList
List<Integer> list1 = new LinkedList<>();
List<String> list2 = new java.util.ArrayList<>();
list2.add("JavaSE");
list2.add("JavaWeb");
list2.add("JavaEE");
// 使用ArrayList构造LinkedList
List<String> list3 = new LinkedList<>(list2);
}

 LinkedList的遍历

public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<>();
list.add(1); // add(elem): 表示尾插
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.add(7);
System.out.println(list.size());
// foreach遍历
for (int e:list) {
System.out.print(e + " ");
} S
ystem.out.println();
// 使用迭代器遍历---正向遍历
ListIterator<Integer> it = list.listIterator();
while(it.hasNext()){
System.out.print(it.next()+ " ");
} S
ystem.out.println();
// 使用反向迭代器---反向遍历
ListIterator<Integer> rit = list.listIterator(list.size());
while (rit.hasPrevious()){
System.out.print(rit.previous() +" ");
} S
ystem.out.println();
}

链表的概念

链表的实现

// 1、无头单向非循环链表实现
public class SingleLinkedList {
//头插法
public void addFirst(int data);
//尾插法
public void addLast(int data);
//任意位置插入,第一个数据节点为0号下标
public boolean addIndex(int index,int data);
//查找是否包含关键字key是否在单链表当中
public boolean contains(int key);
//删除第一次出现关键字为key的节点
public void remove(int key);
//删除所有值为key的节点
public void removeAllKey(int key);
//得到单链表的长度
public int size();
public void toString();
public void clear();
}

具体源代码 

 

import javax.xml.soap.Node;

class ListNode {
    public int val;
    public ListNode next;

    public ListNode(int val) {
        this.val = val;
    }
}

public class SingleLinkedlist {
    public ListNode head;
    public int usedsize;

    public void Creatlist(){
        ListNode node1 = new ListNode(15);
        ListNode node2 = new ListNode(23);
        ListNode node3 = new ListNode(34);
        ListNode node4 = new ListNode(45);
        ListNode node5 = new ListNode(56);
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;
        usedsize = 5;
        this.head = node1;

    }
    public void myToString(){
        ListNode cur=head;
        while(cur!=null){
            System.out.println(cur.val+" ");
            cur=cur.next;
        }
        System.out.println();
    }

    public void myToString(ListNode newhead){
        ListNode cur=newhead;
        while(cur!=null){
            System.out.println(cur.val+" ");
            cur=cur.next;
        }
        System.out.println();
    }
    public boolean contains(int key){
        ListNode cur=head;
        while(cur!=null){
            if(cur.val==key){
                return true;
            }
            cur=cur.next;
        }
        return false;
    }
    public int size(){
        ListNode cur=this.head;
        int count=0;
        while(cur!=null){
            count++;
            cur=cur.next;
        }
        return count;
    }
    public int size2(){
        return usedsize;
    }

    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        if (head == null) {
            head = node;
        } else {
            node.next = head;
            head=node;
        }
        usedsize++;
    }
    public void addLast(int data){
        ListNode node= new ListNode(data);
        ListNode cur=head;
        if(head==null){
            head=node;
        }
        else{
            while(cur.next!=null){
                cur=cur.next;
            }
            cur.next=node;
        }
usedsize++;
    }
    private ListNode searchIndex(int index) {
        ListNode cur=head;
        int count=0;
        while(count!=index-1){
            cur=cur.next;
            count++;
        }
        return cur;
    }
    public void addIndex(int index,int data){
        if(index<0||index>usedsize){
            System.out.println("插入位置不合法");
        }
        if(index==0){
            addFirst(data);
        }
        if(index==usedsize){
            addLast(data);
        }

            ListNode cur=searchIndex(index);
            ListNode node=new ListNode(data);
            node.next=cur.next;
            cur.next=node;

        usedsize++;
    }
    private ListNode findPrevNode(int key) {
        ListNode prev=this.head;
        while(prev.next!=null){
            if(prev.next.val==key){
                return prev;
            }
            prev=prev.next;
        }
        return null;
    }

    public void remove(int key){
        if(head==null){
            return;
        }
        if(head.val==key){
            head=head.next;
        }
        ListNode prev=findPrevNode(key);
        ListNode del=prev.next;
        prev.next=del.next;
        usedsize--;
    }
    public void removeAllKey(int key){
        ListNode prev=head;
        ListNode cur=head.next;
        if(head==null){
            return;

        }
        while (cur!=null){
            if(cur.val==key){
                prev.next=cur.next;
                cur=cur.next;
                usedsize--;
            }
            else{
                cur=cur.next;
                prev=cur;
            }
        }
        if(head.val==key);
        {
            head=head.next;
            usedsize--;
        }
    }
    public void clear1(){
        this.head=null;
    }

}