数据结构与算法——链表(LinkedList)

链表( Linked List )

1 单链表

  • 链表是以节点的方式来存储的,是链式存储
  • 每个节点包含data域,next域:指向下一个节点
  • 链表的各个节点不一定是连续存储的
  • 链表分带头结点的链表和没有头节点的链表,根据实际需求来确定
1.1 添加节点
  • 第一种方式:在添加英雄时直接添加到链表的尾部
    1. 先创建一个head头节点,作用解释表示单链表的头
    2. 后面我们每添加一个节点,就直接加入到链表的最后
    3. 通过一个辅助变量,遍历整个链表
  • 第二种方式:在添加英雄时,根据排名将英雄插入到指定位置
    1. 首先找到新添加的节点的位置,是通过辅助变量(指针)
    2. 新的节点.next = temp.next
    3. temp.next = 新的节点
1.2 修改节点
  1. 先找到该节点,通过遍历
  2. 然后依次将新节点的内容替换到辅助节点上
1.3 删除节点
  1. 我们先找到需要删除的这个节点的前一个节点temp
  2. temp.next = temp.next.next
  3. 被删除的节点,将不会有其他引用指向,会被垃圾回收机制回收
1.4 示例代码
package com.crisp.LinkedList;

public class SingleLinkedListDemo {
    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,"林冲","豹子头");

        //创建要给链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
/*        singleLinkedList.add(hero1);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero4);
        System.out.println();*/
        //排序后输出
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero2);
        //singleLinkedList.addByOrder(hero3);//测试重复添加英雄
        //显示
        singleLinkedList.list();
        System.out.println();
        //测试修改节点的代码
        System.out.println("更改3号节点:");
        HeroNode hero5 = new HeroNode(3,"吴用","智多星");
        singleLinkedList.update(hero5);
        singleLinkedList.list();
        System.out.println();
        //测试删除一个节点
        System.out.println("删除1号节点");
        singleLinkedList.delete(1);
        singleLinkedList.list();
    }
}

//定义SingleLinkedList 管理英雄
class SingleLinkedList {
    //先初始化一个头节点,头节点不要动,不存放具体的数据
    private HeroNode head = new HeroNode(0,"","");

    //添加节点到单向链表
    //思路,当不考虑编号顺序时
    //1、找到当前链表的最后节点
    //2、将最后这个节点的next 指向 新的节点
    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{
            //插入到链表中
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    //修改节点的信息,根据no 编号来修改,即no编号不能改
    //说明:
    //1、根据newHeroNode的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("没有找到编号为 %d 的节点,不能更改\n",newHeroNode.no);
        }
    }
    //删除节点
    //思路:
    //1、head 不能动,因此我们需要一个temp辅助节点找到待删除节点的前一个节点
    //2、说明我们在比较时,是temp.next.no 和 需要删除的节点的no比较
    public void delete(int no){
        //找到需要修改的节点,根据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;
        }
        //根据flag 判断是否找到要删除的节点
        if(flag){
            temp.next = temp.next.next;
        }else{//没有找到
            System.out.printf("没有找到编号为 %d 的节点,无法删除\n",no);
        }
    }



    //显示链表[遍历]
    public void list(){
        //先判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //因为头节点不能动,因此我们需要一个辅助变量来遍历
        HeroNode temp = head.next;
        while(true){
            //判断是否到链表最后
            if(temp == null){
                break;
            }
            //输出节点的信息
            System.out.println(temp);
            //将temp 后移
            temp = temp.next;
        }
    }
}



//定义一个HeroNode,每个HeroNode对象就是一个节点
class HeroNode {
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;//指向下一个节点
    //构造器
    public HeroNode(int hNo,String hName,String hNickname){
        this.no = hNo;
        this.name = hName;
        this.nickname = hNickname;
    }

    //为了显示方便,我们重写toString()
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}
1.5 单链表面试题

单链表常见的面试题有如下:

(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 个节点(新浪)

思路:

  1. 编写一个方法,接收head节点,同时接收一个index
  2. index 表示倒数第index
  3. 先把链表从头到尾遍历,得到链表的总的长度 getLength
  4. 得到size 之后我们从链表的第一个开始遍历 (size - index)个,就可以得到
//思路:
    //1、编写一个方法,接收head节点,同时接收一个index
    //2、index 表示倒数第index个
    //3、先把链表从头到尾遍历,得到链表的总的长度 getLength
    //4、得到size 之后我们从链表的第一个开始遍历 (size - index)个,就可以得到
    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)单链表的反转(腾讯)

思路:

  1. 先定义一个节点 reverseHead = new HeroNode();
  2. 从头到尾遍历原来的链表,每遍历一个节点,就将其取出,并放在新的链表reverseHead的最前端
  3. 原来的链表的head.next = reverseHead.next
//单链表的反转(腾讯)
    public static void ReverseList(HeroNode head){
        //判断链表为空,返回null
        if(head.next == null || head.next.next == null){
            return;
        }
        //定义一个辅助的指针,帮助我们比哪里原来的链表
        HeroNode cur = head.next;
        HeroNode next = null;
        //定义反转节点
        HeroNode reverseHead = new HeroNode(0,"","");
        //遍历原来的链表,每遍历一个节点,就将其取出,并放在新链表reverseList的最前端
        while(cur != null){
            next = cur.next;
            cur.next = reverseHead.next;
            reverseHead.next = cur;
            cur = next;
        }
        head.next = reverseHead.next;
    }
(4)从尾到头打印单链表(百度,要求方式1:反向遍历。方式2:Stack 栈)

思路:

  1. 此题的要求就是逆序打印单链表
  2. 方式1:先将单链表进行反转操作,然后再遍历即可,这样做的问题是会破环原来的的单链表的结构,不建议
  3. 方式2:可以利用栈这个数据结构,将各个节点压入栈中,然后利用栈的先进后出的特点,就实现了逆序打印的效果
	//方式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 后移,压入下一个节点
        }
        //将栈中的节点打印
        while(stack.size() > 0){
            System.out.println(stack.pop());//stack的特点是先进后出
        }
    }

2 双链表

管理单向列表的缺点分析:

  1. 单向链表,查找的方向只能是一个方向,而双向链表可以向前或者向后查找
  2. 单向链表不能自我删除,需要靠辅助节点,而双向链表,则可以自我删除。所以前面我们删除单链表的节点时,总是找到temp 的下一个节点来删除

分析双向链表的增删改查:

  • 遍历方式和单链表一样,只是可以向前,也可以向后查找
  • 添加(默认添加到双向链表的最后节点)
    1. 先找到双向链表的最后这个节点
    2. temp.next = newHeroNode
    3. newHeroNode.pre = temp
  • 修改 的思路和原理和单向链表一样
  • 删除
    1. 因为是双向链表,因此,我们可以实现自我删除某个节点
    2. 直接找到要删除的这个节点,例如temp
    3. temp.pre.next = temp.next
    4. temp.next.pre = temp.pre
示例代码:
package com.crisp.LinkedList;

import org.w3c.dom.Node;

public class DoubleLinkedListDemo {
    public static void main(String[] args) {
        //进行测试
        //先创建节点
        HeroNode2 hero1 = new HeroNode2(1, "宋江", "及时雨");
        HeroNode2 hero2 = new HeroNode2(2, "卢俊义", "玉麒麟");
        HeroNode2 hero3 = new HeroNode2(3, "鲁智深", "花和尚");
        HeroNode2 hero4 = new HeroNode2(4, "林冲", "豹子头");

        //添加节点
//        System.out.println("原始链表如下:");
//        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
//        doubleLinkedList.add(hero1);
//        doubleLinkedList.add(hero2);
//        doubleLinkedList.add(hero3);
//        doubleLinkedList.add(hero4);
//        doubleLinkedList.list();

        //按顺序添加节点
        System.out.println("按顺序添加链表如下:");
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.addByOrder(hero4);
        doubleLinkedList.addByOrder(hero3);
        doubleLinkedList.addByOrder(hero2);
        doubleLinkedList.addByOrder(hero1);
        doubleLinkedList.list();


        //修改一个节点
        System.out.println("修改后的链表如下:");
        HeroNode2 hero5 = new HeroNode2(3, "吴用", "智多星");
        doubleLinkedList.update(hero5);
        doubleLinkedList.list();

        //删除一个节点
        System.out.println("删除4号节点后的链表:");
        doubleLinkedList.delete(4);
        doubleLinkedList.list();
    }
}


//创建一个双向链表类
class DoubleLinkedList{
    //初始化头节点
    private HeroNode2 head = new HeroNode2(0,"","");
    //返回头节点
    public HeroNode2 getHead() {
        return head;
    }

    //添加节点到双向链表(默认添加到最后)
    public void add(HeroNode2 newNode){
        //利用辅助函数遍历
        HeroNode2 temp = head;
        while(true){
            if(temp.next == null){
                break;
            }
            temp = temp.next;
        }
        temp.next = newNode;
        newNode.pre = temp;
    }

    //第二种添加方式,按编号顺序来添加好汉
    public void addByOrder(HeroNode2 newNode){
        //利用辅助函数来遍历
        HeroNode2 temp = head;
        while(true){
            if(temp.next == null){
                newNode.next = temp.next;
                temp.next = newNode;
                newNode.pre = temp;
                break;
            }
            if(temp.next.no > newNode.no) {
                newNode.next = temp.next;
                temp.next = newNode;
                newNode.pre = temp;
                break;
            }else if(temp.next.no == newNode.no){
                System.out.println("编号已经存在,无法添加~");
                break;
            }
            temp = temp.next;
        }
    }

    //修改节点的信息
    public void update(HeroNode2 newNode){
        //判断链表是否为空
        if(head.next == null){
            return;
        }
        //遍历节点,找到需要修改的节点
        HeroNode2 temp = head;
        while(true){
            if(temp == null){
                System.out.printf("没有找到编号为 %d 的好汉\n",newNode.no);
                break;
            }
            if(temp.no == newNode.no){
                temp.name = newNode.name;
                temp.nickname = newNode.nickname;
                break;
            }
            temp = temp.next;
        }
    }

    //删除一个节点
    public void delete(int Delno){
        //判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空~无法删除");
        }
        //遍历链表,找到需要删除的节点
        HeroNode2 temp = head.next;
        while(true){
            if(temp == null){
                System.out.printf("没有找到编号为 %d 的好汉\n",Delno);
                break;
            }
            if(temp.no == Delno){
                temp.pre.next = temp.next;
                if(temp.next != null){
                    temp.next.pre = temp.pre;
                }
                break;
            }
            temp = temp.next;
        }
    }


    //显示链表[遍历]
    public void list(){
        //先判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //因为头节点不能动,因此我们需要一个辅助变量来遍历
        HeroNode2 temp = head.next;
        while(true){
            //判断是否到链表最后
            if(temp == null){
                break;
            }
            //输出节点的信息
            System.out.println(temp);
            //将temp 后移
            temp = temp.next;
        }
    }
}

//定义一个HeroNode2 ,其中多了pre 向前节点
class HeroNode2{
    public int no;
    public String name;
    public String nickname;
    public HeroNode2 next;//指向后一个节点
    public HeroNode2 pre;//指向前一个节点
    //构造器
    public HeroNode2(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }
    //重写toString
    @Override
    public String toString() {
        return "HeroNode2{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

3 环形链表

3.1 单向环形链表应用场景
  • Josephu 问题
    • 设编号为1,2,…,n的n个人围坐一圈,约定编号为k(1<=k<=n)的人从1开始报数,数到m的那个人出列,他的下一位又从1开始数,数到m的那个人又出列,依次类推,直到所有人出列为止,由此产生一个出队编号的序列
  • 提示
    • 用一个不带头节点的循环链表来处理Josephu 问题:先构成一个又n个节点的单循环链表,然后由k节点起从1开始计数,计到m时,对应节点从链表中删除,然后再从被删除的节点的下一个节点又开始从1开始计数,直到最后一个节点从链表中删除,算法结束
  • 构建一个单向环形链表思路
    1. 先创建第一个节点,让first 指向该节点,并形成环形
    2. 后面当我们每创建一个新的节点,就把该节点加入到已有的环形链表中即可
  • 遍历环形链表
    1. 先让一个辅助指针cur,指向first节点
    2. 然后通过一个while 循环遍历该环形链表即可。cur.next == first结束
  • 两种方式实现出圈功能:
    • 方法1:创建一个辅助节点temp,初始化在first 指针后面,每次让first 指在需要出圈的节点,然后进行操作
    • 方法2:只用一个first 指针,使其每次指在需要出圈节点的前一个节点,然后进行操作
3.2 Josephu问题实现代码
package com.crisp.LinkedList;

public class Josephu {
    public static void main(String[] args) {
        /*//测试环形链表
        CircleSingleLinkedList josephu = new CircleSingleLinkedList();
        //测试环形链表增加功能
        josephu.addBoy(5);
        josephu.showCircle();
        //测试环形链表删除功能
        josephu.delete(5);
        josephu.showCircle();
        //测试环形链表查找功能
        Boy res = josephu.find(5);
        System.out.println(res);*/
        //测试约瑟夫环
        JosephuRing(10,5,2);
    }

    /**
     * 约瑟夫问题
     * @param sum 游戏总人数
     * @param k 由第k个人开始
     * @param m 每次数m个数
     */
    public static void JosephuRing(int sum,int k,int m){
        //k,sum和m取值校验
        //即k的值小于等于sum且大于0
        //m的值大于1,虽然理论上可以取1,但我们认为这是毫无意义的,就相当于将first放在k上依次遍历
        if(k > sum || k <= 0 || m <= 1){
            System.out.println("~~~数据输入有误,请输入正确的数据!!!~~~");
            return;
        }
        CircleSingleLinkedList josephu = new CircleSingleLinkedList();
        josephu.addBoy(sum);

        //将孩子出圈的顺序存入数组中
        int[] arr = new int[sum];

        //根据需求,环形链表中的first节点对于本问题无影响
        //首先将first指针指向第k个人
        josephu.setFirst(josephu.find(k));
        System.out.printf("移动到第 %d 个人的位置:",k);
        josephu.showCircle();
        Boy temp = josephu.getFirst();

        //从第k个人开始数(m-1)个数
        //由于sum个人,所以一共只需要循环sum次
        for(int i = 0; i < sum; i++){
            for(int j = 2; j < m; j++){
                //将first节点向后移动一位,直到移动在数(m - 1)个数的时候
                josephu.setFirst(josephu.getFirst().getNext());
            }
            if(josephu.getFirst().getNext() == josephu.getFirst()){
                arr[i] = josephu.getFirst().getNo();
                josephu.setFirst(null);
                System.out.printf("~第 %d 次后,所有人都已经出圈~\n",i + 1);
                //输出孩子出约瑟夫环顺序
                System.out.println("孩子们的出圈顺序为:");
                for(int count = 0; count < arr.length; count ++){
                    System.out.printf(" => %d",arr[count]);
                }
                return;
            }
            arr[i] = josephu.getFirst().getNext().getNo();
            //要出圈的人就是first节点的下一个节点
            josephu.getFirst().setNext(josephu.getFirst().getNext().getNext());
            josephu.setFirst(josephu.getFirst().getNext());
            //输出每次出圈后的情况
            System.out.printf("第 %d 次出圈后顺序:",i+1);
            josephu.showCircle();
        }
    }
}

//创建一个环形的单向链表
class CircleSingleLinkedList{
    //创建一个first节点,当前无编号
    private Boy first = null;

    //获取头节点
    public Boy getFirst() {
        return first;
    }

    //设置头节点位置
    public void setFirst(Boy first) {
        this.first = first;
    }

    //添加节点,构建成一个环形的链表
    //直接输入参与游戏的人数
    public void addBoy(int sum){
        //对sum做一个数据校验
        if(sum < 1){
            System.out.println("游戏人数不正确~");
            return;
        }
        //创建一个辅助指针,帮助创建变量
        Boy cur = null;
        //使用for循环创建环形链表
        for(int i = 1; i <= sum; i++){
            //根据编号创建节点
            Boy boy = new Boy(i);
            //如果是第一个小孩
            if(i == 1){
                first = boy;
                first.setNext(first);//构成环
                cur = first;//让cur指向第一个节点
            }else{
                cur.setNext(boy);
                boy.setNext(first);
                cur = boy;
            }
        }
    }

    //删除节点
    public void delete(int delnum){
        //判断链表是否为空
        if(first == null){
            System.out.println("~~~链表为空!!!~~~");
            return;
        }
        //创建两个辅助节点
        //一个跟在另一个的后面
        //由前一个cur1发现需要删除的节点
        //后面的cur2指向发现节点的下一个节点
        Boy cur1 = first.getNext();
        Boy cur2 = first;
        //遍历链表找到需要删除的节点
        while(true){
            //System.out.println(cur1.getNo());
            //System.out.println(cur2.getNo());
            if(cur1.getNo() == delnum){
                 cur2.setNext(cur1.getNext());
                if(cur1.getNo() == first.getNo()){
                    first = cur2.getNext();
                }
                 return;
            }
            if(cur1.getNo() == first.getNo()){
                System.out.println("~没有发现所要删除的节点~");
                return;
            }
            //两个节点均向后移位
            cur1 = cur1.getNext();
            cur2 = cur2.getNext();
        }
    }

    //查找节点
    //由于是一个环形节点
    //所以输入值应该为从头节点开始的第num个数,而不是编号值
    //注意:first节点应该算作第一个数
    public Boy find(int num){
        //定义辅助指针,用来在链表中移动
        Boy temp = first;
        for(int i = num; i > 1; i--){
            temp = temp.getNext();
        }
        return temp;
    }

    //遍历当前环形链表
    public void showCircle(){
        //判断是否为空
        if(first == null){
            System.out.println("链表为空~");
            return;
        }
        //first不可移动,因此使用辅助指针
        Boy temp = first;
        while(true){
            System.out.printf("=> %d ",temp.getNo());
            if(temp.getNext() == first){
                //最后一个节点
                System.out.println();
                return;
            }
            temp = temp.getNext();
        }
    }
}


//创建一个Boy类,表示一个节点
class Boy{
    private int no;//编号
    private Boy next;//指向下一个节点
    //构造器
    public Boy(int no) {
        this.no = no;
    }
    //set方法
    public void setNo(int no) {
        this.no = no;
    }
    public void setNext(Boy next) {
        this.next = next;
    }
    //get方法
    public int getNo() {
        return no;
    }
    public Boy getNext() {
        return next;
    }

    //重写toString,方便查看
    @Override
    public String toString() {
        return "Boy{" +
                "no=" + no +
                '}';
    }
}

你可能感兴趣的:(数据结构与算法,链表,数据结构,java)