数据结构与算法的day02

链表

  是有序列表，链表在内存中的实际结构是向下图中那样，并不是连续的，逻辑结构与实际结构并不一样，头节点不存放任何数据，作用就是表示单链表的头

代码实现单向链表 

  下面以梁山好汉排名实例进行演示，第一种，不按排名插入

package algorithm.day02;

public class LinkedListDemo {
    public static void main(String[] args) {
        //先创建节点
        HeroNode heroNode = new HeroNode(1,"宋江","及时雨");
        HeroNode heroNode1 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode heroNode2 = new HeroNode(3,"吴用","智多星");
        HeroNode heroNode3 = new HeroNode(4,"林冲","豹子头");

        //创建一个链表
        LinkedList list = new LinkedList();
        list.add(heroNode);
        list.add(heroNode1);
        list.add(heroNode2);
        list.add(heroNode3);
        //显示
        list.show();
    }
}


//定义一个LinkedList管理这些英雄
class LinkedList{
    //先初始化一个头节点，头节点不能动
    private HeroNode head = new HeroNode(0,"","");//头节点中没有数据

    //添加节点到单向链表
    //当不考虑编号顺序时，找到这个链表的最后节点，最后这个节点的next指向新节点
    public void add(HeroNode heroNode){
        //因为head节点不动，因此我们需要一个辅助变量temp
        HeroNode temp = head;
        //遍历链表，加到最后
        while (true){
            //找到链表的最后
            if (temp.next == null){
                break;
            }
            //没找到就将temp后移
            temp = temp.next;
        }
        //此时temp指向链表的最后
        temp.next = heroNode;
    }

    //显示链表
    public void show(){
        //先判断链表是否为空
        if (head.next == null){
            return;
        }
        //因为头节点不能动，因此需要一个辅助变量去遍历
        HeroNode temp = head.next;//因为上面已经知道链表不为空，所以temp指向下一个
        while (true){
            //判断是否到链表最后
            if (temp == null){
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }
}
//定义一个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;
    }

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

代码实现按编号添加

 只需要修改添加的代码即可

 public void addByorder(HeroNode heroNode){
        //仍然需要一个辅助指针来帮助找到添加的位置
        //因为是单链表，我们要找的就是插入位置的前一个节点
        HeroNode temp = head;
        boolean flag = false;//表示添加的编号是否存在，默认为false
        while (true){
            if (temp.next == null){//说明temp已经在链表的最后
                break;
            }
            if (temp.next.no > heroNode.no){//找到了要插入的位置
                break;
            }else if (temp.next.no == heroNode.no){//说明希望添加的编号已经存在
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //判断flag的值
        if (flag){//不能添加，说明编号存在
            System.out.printf("准备插入的英雄的编号%d已经存在\n",heroNode.no);
        }else {
            //插入到链表中
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    链表删除的代码

 public void dle(HeroNode heroNode){
        HeroNode temp = head;
        boolean flag = false;
        while (true){
            if (temp.next == null){
                break;
            }
            if (temp.next.no == heroNode.no){
                //找到了待删除的节点的前一个节点
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag == true){
            //可以删除
            temp.next = temp.next.next;
        }else {
            System.out.printf("要删除的%d节点不存在\n",heroNode.no);
        }
    }

 删除

public void dle(HeroNode heroNode){
        HeroNode temp = head;
        boolean flag = false;
        while (true){
            if (temp.next == null){
                break;
            }
            if (temp.next.no == heroNode.no){
                //找到了待删除的节点的前一个节点
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag == true){
            //可以删除
            temp.next = temp.next.next;
        }else {
            System.out.printf("要删除的%d节点不存在\n",heroNode.no);
        }
    }

单链表的面试题

  1、获取单链表的节点个数

 public int getLength(HeroNode head){
        HeroNode temp = head.next;
        if (head.next == null){//空链表
            return 0;
        }
        int length = 0;
        while (temp != null){
            length++;
            temp = temp.next;
        }
        return length;
    }

2、查找单链表的倒数第k个节点

public HeroNode findLastIndex(HeroNode head, int index){
        //判断链表是否为空
        if (head.next == null){
            return null;//没有找到
        }
        //第一次遍历得到链表的长度
        int size = getLength(head);
        //第二次遍历size-index的位置，就是倒数第k个节点
        //做数据校验
        if (index <= 0 || index > size){
            return null;
        }
        //定义一个辅助变量
        HeroNode temp = head.next;
        for (int i = 0;i < size - index;i++){
            temp = temp.next;
        }
        return temp;
    }

单链表的反转

  这个较为难理解，主要是对next的理解

 public void reversetList(HeroNode head){
        //如果当前链表为空，或者只有一个节点，无需反转
        if (head.next == null || head.next == null){
            return;
        }

        //定义一个辅助的指针，帮助遍历数组
        HeroNode temp = head.next;
        HeroNode next = null;//指向当前节点【cur】的下一个节点，帮助存储
        HeroNode reverseHead = new HeroNode(0,"","");//它的next并不是没有，而是指向空的
        //遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的前面
        while (temp != null){
            next = temp.next;//先暂时保存当前节点的下一个节点
            temp.next = reverseHead.next;//将temp的下一个节点指向新的链表的最前端
            reverseHead.next = temp;//这里谨记.next的意思是一条线指向哪里
            temp = next;//让temp后移
        }
        //将head.next 指向 reverseHead.next，实现单链表的反转
        head.next = reverseHead.next;
    }
}

今日学习到此结束