数据结构之单链表的使用

一、链表(LinkedList)介绍

链表是有序的列表，但是它在内存中是存储如下：

 

 上图小结：

1）链表是以节点的方式存储的，是链式存储。

2）每个节点包含 data 域，next 域：指向写一个节点。

3）如图：发现链表的各个节点不一定是连续存储的。

4）链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定。

• 单链表（带头节点）逻辑示意图如下：

　　

 

 二、单链表的应用实例

　　使用带 head 头的单向链表实现 - 水浒英雄排行榜管理完成对英雄任务的增删改查操作。

1）第一种方法在添加英雄时，直接添加到链表的尾部

　　思路示意图：

 

 2）第二种方式在添加英雄时，根据排名将英雄插入到指定的位置（如果链表中已经存在此排名，则添加失败，给出提示信息），思路示意图如下：

 

 3）修改节点功能

思路：① 通过遍历，先找到该节点，② temp.name= newNode.name; temp.nickName = newNode.nickName;

4）删除节点

思路示意图：

 

 5）完整的代码演示

/**
 * 单链表的应用实例
 */
public class SingleLinkedListDemo {

    public static void main(String[] args) {

        SingleLinkedList list = new SingleLinkedList();

        HeroNode hero1 = new HeroNode(1,"宋江","及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(3,"吴用","智多星");
        HeroNode hero4 = new HeroNode(4,"林冲","豹子头");

        /*list.add(hero1);
        list.add(hero2);
        list.add(hero3);
        list.add(hero4);*/

        list.add2(hero1);
        list.add2(hero2);
        list.add2(hero4);
        list.add2(hero3);

        HeroNode hero5 = new HeroNode(5,"林冲","豹子头");
        list.delete(hero5);
        list.list();

    }
}


//创建 SingleLinkedList,管理我们的英雄
class SingleLinkedList{
    //先创建一个头节点，头节点不能动，不存放具体的数据
    private HeroNode head = new HeroNode(0,"","");

    //添加节点到单向链表
    //思路：当不考虑编号顺序时
    //1.找到当前链表的最后节点
    //2.将最后这个节点的 next 域指向新的节点
    public void add(HeroNode node){
        //因为 head 节点不能动，所以我们需要一个辅助节点 temp
        HeroNode temp = head;

        //通过遍历找到链表的最后节点
        while (temp.next != null){
            temp = temp.next;
        }

        //让链表的最后节点的 next 域指向新的节点
        temp.next = node;
    }

    //第二种方式在添加英雄时，根据排名将英雄添加到指定位置
    //（如果有这个排名，则添加失败，并给出提示）
    public void add2(HeroNode node){
        //因为 head 节点不能动，所以我们需要一个辅助节点 temp
        //我们必须找到添加位置的前一个节点，否则添加不了
        HeroNode temp = head;
        boolean flag = false;

        while (true){
            if(temp.next == null){//说明 temp 已经在链表的最后
                break;
            }

            if(temp.next.no > node.no){//找到了添加位置的前一个节点，就是 temp
                break;
            }else if(temp.next.no == node.no){
                flag = true;
                break;
            }

            temp = temp.next;//将 temp 后移,遍历当前链表
        }

        if(flag){
            System.out.println("此编号已经存在，无法插入");
        }else{
            node.next = temp.next;//将 node 的 next 域指向 temp.next
            temp.next = node;//将temp.next 指向 node
        }

    }


    //遍历显示链表
    public void list(){
        //如果链表为空
        if(head.next == null){
            System.out.println("链表为空！！！");
            return;
        }

        //因为 head 节点不能动，所以我们需要一个辅助节点 temp
        HeroNode temp = head;

        while (temp.next != null){
            //输出节点信息
            System.out.println(temp.next);
            //将 temp 后移
            temp = temp.next;
        }

    }

    //修改节点，根据 no 修改，即 no 不能改
    public void update(HeroNode node){
        //判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }

        //因为 head 节点不能动，所以我们需要一个辅助节点 temp
        HeroNode temp = head;
        boolean flag = false;//表示是否找到该节点
        while (true){
            if(temp.next == null){//说明 temp 已经在链表的最后
                break;
            }
            if(temp.next.no == node.no){
                flag = true;//找到了
                break;
            }

            temp = temp.next;//将 temp 后移
        }

        if(flag){
            temp.next.name = node.name;
            temp.next.nickName = node.name;
        }else{
            System.out.printf("没有找到编号 %d 的节点，不能修改\n",node.no);
        }
    }

    //删除节点，根据节点的 no 进行删除
    public void delete(HeroNode node){
        //因为 head 节点不能动，所以我们需要一个辅助节点 temp
        HeroNode temp = head;
        boolean flag = false;//表示是否找到该节点

        while (true){
            if(temp.next == null){//说明 temp 已经在链表的最后
                break;
            }

            if(temp.next.no == node.no){
                flag = true;
                break;
            }
            temp = temp.next;//将 temp 后移
        }

        if(flag){//找到该节点
            temp.next = temp.next.next;
        }else{
            System.out.printf("没有找到编号 %d 的节点，不能删除\n",node.no);
        }


    }
}


//创建 HeroNode ,每个 HeroNode 就是一个节点
class HeroNode{
    public int no;
    public String name;
    public String nickName;
    public HeroNode next;//next指向下一个节点

    public HeroNode(int no,String name,String nickName){
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

三、单链表的缺点

 

使用带head头的双向链表实现 –水浒英雄排行榜 管理单向链表的缺点分析:

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

②单向链表不能自我删除，需要靠辅助节点 ，而双向链表，则可以自我删除，所以前面我们单链表删除时节点，

    总是找到temp,temp是待删除节点的前一个节点(认真体会).

四、单向链表面试题（新浪，百度，腾讯）

1）求单链表中的有效节点

思路：遍历整个链表，每遍历一个节点，变量length+1

//方法：获取到单链表的节点的个数(如果是带头结点的链表，需求不统计头节点)
    /**
     * @param head 链表的头节点
     * @return 返回的就是有效节点的个数
     */
    public static int getLength(HeroNode head) {
        if(head.next == null) { //空链表
            return 0;
        }
        int length = 0;
        //定义一个辅助的变量, 这里我们没有统计头节点
        HeroNode cur = head.next;
        while(cur != null) {
            length++;
            cur = cur.next; //遍历
        }
        return length;
    }

2）查找单链表中的倒数第 k 个节点（新浪面试题）

思路：先获取链表的优先节点个数length，之后遍历取得 length - k 节点

//查找单链表中的倒数第k个结点 【新浪面试题】
    //思路
    //1. 编写一个方法，接收head节点，同时接收一个index
    //2. index 表示是倒数第index个节点
    //3. 先把链表从头到尾遍历，得到链表的总的长度 getLength
    //4. 得到size 后，我们从链表的第一个开始遍历 (size-index)个，就可以得到
    //5. 如果找到了，则返回该节点，否则返回nulll
    public static HeroNode findLastIndexNode(HeroNode head, int index) {
        //判断如果链表为空，返回null
        if(head.next == null) {
            return null;//没有找到
        }
        //第一个遍历得到链表的长度(节点个数)
        int size = getLength(head);
        //第二次遍历  size-index 位置，就是我们倒数的第K个节点
        //先做一个index的校验
        if(index <=0 || index > size) {
            return null;
        }
        //定义给辅助变量， for 循环定位到倒数的index
        HeroNode cur = head.next; 
        for(int i =0; i< size - index; i++) {
            cur = cur.next;
        }
        return cur;

    }

3）单链表的反转（腾讯面试题，有点难度）

思路：定义一个新的链表 reverseHead ，第一步：遍历原来的链表，将每一个原来链表的节点【cur】的 next 域 指向 reverseHead 的第一个节点，

　　   第二步：将 reverseHead  的 next 域指向 cur节点。如下图

 

 代码如下：

//反转链表
    public static void reverseLinkedList(HeroNode head){
        //如果链表为空或者链表只有一个有效节点
        if(head.next == null || head.next.next == null){
            return ;
        }

        HeroNode cur = head.next;//定义一个辅助指针，帮助我们遍历链表
        HeroNode next = null;//指向当前节点[cur]的下一个节点，作用就是为我们保存下一个节点的位置，以便我们后面使用
        HeroNode reverseHead = new HeroNode(0,"","");//反转链表

        while (cur != null){
            next = cur.next;//先暂时保存当前节点的下一个节点，后面需要使用

            //将当前节点的下一个节点指向 reverseHead 的最前端，
            //这里需要思考下，因为不能只将 reverseHead 的 next 节点指向 cur，
            //还需要先将 cur 的 next 节点指向 reverseHead 的 next 节点
            cur.next = reverseHead.next;
            reverseHead.next = cur;
            cur = next;
        }

        //最终将 head 指向 reverseHead 的 第一个节点，完成反转
        head.next = reverseHead.next;
    }

4）从尾到头打印单链表（百度，要求方式1：反向遍历。方式2：Stack栈）

//方式2：
    //可以利用栈这个数据结构，将各个节点压入到栈中，然后利用栈的先进后出的特点，就实现了逆序打印的效果
    public static void reversePrint(HeroNode head) {
        if(head.next == null) {
            return;//空链表，不能打印
        }
        //创建要给一个栈，将各个节点压入栈
        Stack<HeroNode> stack = new Stack<HeroNode>();
        HeroNode cur = head.next;
        //将链表的所有节点压入栈
        while(cur != null) {
            stack.push(cur);
            cur = cur.next; //cur后移，这样就可以压入下一个节点
        }
        //将栈中的节点进行打印,pop 出栈
        while (stack.size() > 0) {
            System.out.println(stack.pop()); //stack的特点是先进后出
        }
    }