Java数据结构-单向链表

Posted 2021-10-10 之墨_

Java数据结构-单向链表

• 1、链表
• 2、代码实现
• 3、实战面试题
• • • 新浪面试题
    • 腾讯面试题
    • 百度面试题

1、链表

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

小结:

1. 链表是以节点的方式来存储,是链式存储
2. 每个节点包含 data 域， next 域：指向下一个节点.
3. 如图：发现链表的各个节点不一定是连续存储.
4. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定

2、代码实现

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

定义HeroNode，每个HeroNode对象就是一个节点：

class HeroNode{
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;//指向下一个节点

    //构造器
    public HeroNode(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

在添加英雄时，直接添加到链表的尾部：

public void add (HeroNode heroNode){
        //因为head节点不变化，所以需要一个辅助遍历temp
        HeroNode temp = head;
        //遍历链表，找到最后
        while(true){
            //找到链表的最后
            if(temp.next == null){
                break;
            }
            //如果没有找到最后，就将temp后移
            temp = temp.next;
        }
        //当推出while循环时，temp就指向了链表的最后
        //将最后这个节点的next指向新的节点
        temp.next = heroNode;
    }

在添加英雄时，根据排名将英雄插入到指定位置(如果有这个排名，则添加失败，并给出提示)：

 public void addByOrder(HeroNode heroNode){
        //因为是是单链表，所以我们找到的temp是位于添加位置的前一个节点，否则插入失败
        HeroNode temp = head;
        boolean flag = false;//标志添加的编号是否存在，默认为false
        while (true){
            if(temp.next == null){
                //temp已经在链表的最后
                break;
            }
            if(temp.next.no > heroNode.no){
                //位置找到，就在temp的后面插入
                break;
            }else if(temp.next.no == heroNode.no){
                //想添加的heroNode的编号已经存在
                flag = true;
                break;
            }
            temp = temp.next;//后移，遍历当前链表
        }
        //判断flag的值
        if(flag){
            //不能添加，说明编号存在
            System.out.printf("此英雄编号 %d 已经存在，不能加入\\n",heroNode.no);
        }else{
            //插入到链表中，temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

显示链表【遍历】：

 public  void list(){
        //判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //因为head节点不变化，所以需要一个辅助遍历temp
        HeroNode temp = head.next;
        while (true){
            //判断是否到链表的最后
            if(temp == null){
                break;
            }
            //输出节点的信息
            System.out.println(temp);
            //将temp后移
            temp = temp.next;
        }
    }
}

修改节点的信息，根据编号no进行修改，no编号不能修改：

   public void update(HeroNode newHeroNode){
        //判断是否为空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点，根据no编号
        //定义一个辅助变量
        HeroNode temp = head.next;
        boolean flag = false;//表示是否找到节点
        while (true){
            if(temp == null){
                break;//遍历完成
            }
            if(temp.no == newHeroNode.no){
                //找到
                flag = true;
                break;
            }
            temp =temp.next;
        }
        //根据flag判断是否找到要修改的节点
        if(flag){
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        }else {
            //没有找到
            System.out.printf("没有找到编号为%的节点，不能修改\\n",newHeroNode.no);
        }
    }

删除节点：
在比较时，是temp.next.no和需要删除的节点的no进行比较

public void del(int no){
    HeroNode temp = head;
    boolean flag = false;
    while (true){
        if(temp.next == null){
            //到了链表的最后
            break;
        }
        if(temp.next.no == no){
            //找到待删除节点的前一个节点
            flag = true;
            break;
        }
    temp = temp.next;//temp后移遍历
    }
    //判断flag
    if(flag){
        //找到
        //可以删除
        temp.next = temp.next.next;
    }else {
        System.out.printf("要删除的%d节点不存在\\n",no);
    }
}

测试主程序：

 public static void main(String[] args) {
        //进行测试
        //先创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");

        //创建一个链表
        SingleLinkedListPlus singleLinkedList = new SingleLinkedListPlus();
        //加入
//        singleLinkedList.add(hero1);
//        singleLinkedList.add(hero2);
//        singleLinkedList.add(hero3);
//        singleLinkedList.add(hero4);

        //加入按照编号的顺序
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        //显示单链表
        singleLinkedList.list();

        //测试修改节点
        HeroNode newHeroNode = new HeroNode(2,"小卢","貔貅");
        singleLinkedList.update(newHeroNode);

        System.out.println("修改后的链表：");
        singleLinkedList.list();

        //删除应该节点
        singleLinkedList.del(1);
        singleLinkedList.del(2);
        System.out.println("删除后的链表：");
        singleLinkedList.list();
    }

3、实战面试题

新浪面试题

查找单链表中的倒数第k个结点

思路

1. 编写一个方法，接收head节点，同时接收一个index
2. index 表示是倒数第index个节点
3. 先把链表从头到尾遍历，得到链表的总的长度 getLength
4. 得到size 后，我们从链表的第一个开始遍历 (size-index)个，就可以得到
5. 如果找到了，则返回该节点，否则返回null

代码实现

   
    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; //3 // 3 - 1 = 2
        for(int i =0; i< size - index; i++) {
            cur = cur.next;
        }
        return cur;
    }

    //方法：获取到单链表的节点的个数(如果是带头结点的链表，需求不统计头节点)
    /**
     *
     * @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;
    }
}

关键代码

//定义给辅助变量， for 循环定位到倒数的index
HeroNode cur = head.next; //3 // 3 - 1 = 2
for(int i =0; i< size - index; i++) {
    cur = cur.next;
}
return cur;

  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;
    }

腾讯面试题

单链表的反转

思路:

1. 先定义一个节点reverseHead =new HeroNode();
2. 从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端.
3. 原来的链表的head.next =reverseHead.next

代码实现

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

     //定义一个辅助的指针，帮助我们遍历原来的链表
        HeroNode cur = head.next;
        HeroNode next =null;//指向当前节点cur的下一个节点
        HeroNode reverseHead = new HeroNode(0,"","");
        //遍历原来的链表，遍历一个节点就取出放在reverseHead链表的最前端
        while (cur != null){
            next = cur.next;//先暂时保存当前节点的下一个节点，后面需要使用
            cur.next = reverseHead.next;//将cur的下一个节点指向新的链表的最前端
            reverseHead.next=cur;//将cur连接到新的链表上
            cur = next;//让cur后移
        }
        //让head.next指向reveseHead.next
        head.next = reverseHead.next;
    }

关键代码

//定义一个辅助的指针，帮助我们遍历原来的链表
    HeroNode cur = head.next;
    HeroNode next =null;//指向当前节点cur的下一个节点
    HeroNode reverseHead = new HeroNode(0,"","");
    //遍历原来的链表，遍历一个节点就取出放在reverseHead链表的最前端
while (cur != null){
        next = cur.next;//先暂时保存当前节点的下一个节点，后面需要使用
        cur.next = reverseHead.next;//将cur的下一个节点指向新的链表的最前端
        reverseHead.next=cur;//将cur连接到新的链表上
        cur = next;//让cur后移
    }
    //让head.next指向reveseHead.next
    head.next = reverseHead.next;

百度面试题

逆序打印单链表

思路

1. 要求是逆序打印单链表
2. 方式1:先将单链表进行反转操作，然后再遍历即可，这样的做的问题是会破坏原来的单链表的结构，不建议
3. 方式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先进后出
        }
    }