面试考点（一）——单链表的基本操作

引言

在面试的笔试中，经常考链表的基本操作。在此总结如下：
1、基本的链表构建（头插法和尾插法）
2、查找某个元素是否在链表的结点上
3、指定位置插入结点
4、删除指定位置结点
5、对链表进行翻转
6、截取链表后k个值
7、合并两个有序链表
8、判断链表是否成环

前期准备（定义链表节点）

public class ListNode {
    private int val;
    private ListNode next;
    
    public ListNode(int val){
        this.val=val;
    }
    
    public void setVal(int val){
        this.val=val;
    }

    public int getVal() {
        return val;
    }

    public ListNode getNext() {
        return next;
    }

    public void setNext(ListNode next) {
        this.next = next;
    }
}

1、构建链表

public class LinkList {
    /**
     * 定义链表头结点
     **/
    ListNode head=null;
    /**
     * 尾插法
     **/
    public void endInsert(int val){
        //新建结点
        ListNode newNode=new ListNode(val);
        //判断头结点是否为空
        if(head==null){
            head=newNode;
            return;
        }
        //定义指针指向链表头结点
        ListNode indexNode=head;
        //判断当前结点的指针域地址是否为空
        while(indexNode.getNext()!=null){
            indexNode=indexNode.getNext();
        }
        //当前结点的指针域存储新结点的地址
        indexNode.setNext(newNode);
    }
    /**
     * 头插法
     **/
    public void headInsert(int val){
        //新建结点
        ListNode newNode=new ListNode(val);
        //判断头结点是否为空
        if(head==null){
            head=newNode;
            return;
        }
        //新结点的指针域设置为第一个结点的地址
        newNode.setNext(head);
        //头结点储存新结点的地址
        head=newNode;
    }
}

2、查找元素（本质上是遍历链表）

public class LinkList {
    /**
     * 定义链表头结点
     **/
    ListNode head=null;
    
    public boolean searchVal(int value){
        ListNode temp=head;
        while(temp!=null){
            if(temp.getVal()==value){
                return true;
            }
            temp=temp.getNext();
        }
        return false;
    }
}

3、插入元素到指定位置

实现思路：
1、先判断插入位置为头尾两端的情况：
1）index == 0 头插法插入到头部
2）index == length 尾插法插入到尾部
2、如果插入位置不是头尾两端：
1）找出当前 index 位置的结点 cur 以及前一个结点 pre
2）然后 cur 成为新结点的下一个结点，新结点成为 pre 的后一个结点

public class LinkList {
    /**
     * 定义链表头结点
     **/
    ListNode head=null;
    
    /**
     * 返回链表长度
     **/
    public int getLength() {
        ListNode indexNode = head;
        int count = 0;
        while (indexNode != null) {
            indexNode = indexNode.getNext();
            count++;
        }
        return count;
    }
    /**
     * 指定位置插入值
     **/
    public void insertVal(int pi, int val) {
        if (pi < 0 || pi > getLength() + 1) {
            System.out.println("插入位置错误");
        }
        if (pi == 0) {
            headInsert(val);
        } else if (pi == getLength() + 1) {
            endInsert(val);
        } else {
            ListNode newNode = new ListNode(val);
            ListNode temp = head;
            ListNode pre = null;
            //p记位置
            int p = 0;
            while (temp != null) {
                if (p == pi - 1) {
                    newNode.setNext(temp);
                    pre.setNext(newNode);
                    return;
                }
                pre = temp;
                temp = temp.getNext();
                p++;
            }
        }
    }
}

4、删除指定位置结点

public class LinkList {
    /**
     * 定义链表头结点
     **/
    ListNode head=null;
    
    /**
     * 删除指定结点
     **/
    public void deleteNode(int pi) {
        if (pi < 0 || pi >= getLength()) {
            throw new IndexOutOfBoundsException("删除位置错误");
        }
        if (pi == 0) {
            head = head.getNext();
            return;
        }
        ListNode temp = head;
        ListNode pre = null;
        //p记位置
        int p = 0;
        while (temp != null) {
            if (p == pi - 1) {
                pre.setNext(temp.getNext());
                temp.setNext(null);
                return;
            }
            pre = temp;
            temp = temp.getNext();
            p++;
        }
    }
}

5、翻转链表

实现思路：假设我们准备1-》2-》3-》4
1、准备两个空结点 pre用来保存先前结点、next 用来做临时变量
2、在头结点node遍历的时候此时为1结点
3、next = 1结点.next(2结点)
4、1结点.next=pre(null)
5、pre = 1结点
6、node = 2结点
7、进行下一次循环node=2结点
8、next = 2结点.next(3结点)
9、2结点.next=pre(1结点)=>即完成2->1
10、pre = 2结点
11、node = 3结点

    /**
     * 链表的翻转
     **/
    public ListNode reverseLinkList(ListNode head) {
        System.out.println(head.getVal());
        //pre用来保存先前结点
        ListNode pre = null;
        //next用来做临时变量
        ListNode next = null;
        while (head != null) {
            next = head.getNext();
            head.getNext().setNext(pre);
            pre = head;
            head = next;
        }
        return pre;
    }

6、截取后k个值

实现思路：
1、使用两个指针，先让前面的指针走到正向第k个结点，这样前后两个指针的距离差是k-1
2、之后前后两个指针一起向前走，前面的指针走到最后一个结点时，后面指针所指就是后K个结点

    /**
     * 截取后k个值
     **/
    public void getK(int n) {
        if (n < 0 || n >= getLength()) {
            throw new IndexOutOfBoundsException("位置错误");
        }
        ListNode k = head;
        ListNode m = head;
        while (k != null && n >= 1) {
            k = k.getNext();
            n--;
        }
        while (k != null) {
            k = k.getNext();
            m = m.getNext();
        }
        head = m;
    }

7、合并有序链表

实现思路：合并两个有序列表 ：
1、首先需要一个指针永远指向第一个节点，
2、两一个指针需要不断的向后走进项比较。
3、当有一条链表为空的时候，另一条链表的数据全部放过来

    public void heBing(ListNode n1, ListNode n2){
        ListNode temp= new ListNode(0);
        while(n1!=null&&n2!=null){
            if(n1.getVal()>n2.getVal()){
                temp.setNext(n2);
                n2=n2.getNext();
            }else{
                temp.setNext(n1);
                n1=n1.getNext();
            }
            temp = temp.getNext();
        }
        if(n1 == null){
            temp.setNext(n2);
        }
        if(n2 == null) {
            temp.setNext(n1);
        }
    }

8、判断链表是否成环

实现思路：
1、如果一个链表中有环，也就是说用一个指针去遍历，是永远走不到头的。
2、使用两个指针去遍历，一个指针一次走两步， 一个指针一次走一步。
3、如果有环，两个指针肯定会在环中相遇。

    /**
     * 判断链表是否成环
     **/
    public boolean hasCircle() {
        ListNode fast = head;
        ListNode slow = head;
        while ((fast != null) && (fast.getNext() != null)) {
            fast = fast.getNext().getNext();
            slow = slow.getNext();
            if (fast == slow) {
                return true;
            }
        }
        return false;
    }

总结

总结到此为止，希望能够对你的面试有帮助