03--链表之-->单链表

• 链表的物理存储结构：

 

 特点：

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

•  案例：定义单链表实现三国英雄任务增删查改以及排序、遍历、合并等操作

//定义一个HeroNode类，每一个HeroNode类的对象都是要给节点，包含对象的属性以及下一个节点的地址
class HeroNode{
    //data域
    public int id;
    public String name;
    public String address;
    
    //创建构造器，用于初始化每个节点中的data域，即为英雄的属性赋值
    public HeroNode(int id,String name,String address) {
        this.id = id;
        this.name = name;
        this.address = address;
    }
    
    //next域，指向下一个节点【默认值为null，代表链表的尾部】
    HeroNode next;

    //重写toString方法，使打印节点对象的地址 --> 打印节点对象的内容【只打印每个节点对象中的data域】
    @Override
    public String toString() {
        return "HeroNode [id=" + id + ", name=" + name + ", address=" + address + "]";
    }
    
}

//定义一个SingleLinkedList类，用于管理整个单链表【带头节点的】
class SingleLinkedList{
    //每个链表对象都会有一个头节点，所以先创建一个头节点对象
    HeroNode headHeroNode = new HeroNode(0, "", "");
    
    //1、直接向单链表的末尾追加节点
    public void addToLast(HeroNode newHeroNode) {
        //头节点不能动，借助辅助指针进行遍历
        HeroNode tmp = headHeroNode;
        while(true) {
            if (tmp.next == null) {
                //说明到了链表的尾部
                tmp.next = newHeroNode;
                break;
            }
            //向后移动
            tmp = tmp.next;
        }
    }
    
    //2、按照id号进行顺序【升序】排序
    //       <-- 3 -->
    //0 1  2           4   5 
    public void addByAscend(HeroNode newHeroNode) {
        //辅助指针进行遍历，找到带升序的节点
        HeroNode tmp = headHeroNode;
        while(true) {
            if(tmp.next == null) {
                //追加到链表的末尾
                tmp.next = newHeroNode;
                break;
            }
            //如果是降序的话此处应改为：newHeroNode.id > tmp.id
            if (tmp.next.id > newHeroNode.id) {
                tmp.next = newHeroNode; //与前一个节点建立连接
                newHeroNode.next = tmp.next;
                break;
            }
            else if(tmp.next.id == newHeroNode.id) {
                System.out.println("id号为：" + newHeroNode.id + "已存在，不能插入");
                break;
            }
            tmp = tmp.next;
        }
    }
    
    //3、修改节点【根据id号查找与之对应的节点】
    //1 -- 3 -- 7 -- 9
    //   3-->5
    public void modify(HeroNode modifyNode) {
        if (headHeroNode.next == null) {
            System.out.println("链表空，无可修改的数据");
        }
        //定义临时指针代替头节点进行遍历
        HeroNode tmp = headHeroNode.next;
        while(true) {
            if (tmp == null) {
                System.out.println("修改失败，原因：未查找到id号为：" + modifyNode.id + "的节点");
                //记得干掉方法
                return;
            }
            if (tmp.id == modifyNode.id) {
                String oldName = tmp.name;
                //其实所谓的修改，就是重新将遍历到的节点中的data域重新赋值
                tmp.id = modifyNode.id;
                tmp.name = modifyNode.name;
                tmp.address = modifyNode.address;
                System.out.println("英雄" + oldName + "的数据已被成功修改~~~");
                break;
            }
            //继续遍历
            tmp = tmp.next;
        }
    }
    
    //4、删除节点 4
    //1 -- 3 -- 4 -- 5 -- 7
    public void delete(HeroNode deleteNode) {
        if(headHeroNode.next == null) {
            System.out.println("链表为空，无可删除的数据");
            return;
        }
        //根据传入节点的id号进行遍历查询
        //同样，头节点不能动，借助辅助指针进行链表的遍历
        HeroNode tmp = headHeroNode;
        while(true) {
            if (tmp == null) {
                System.out.println("删除失败，原因：并未查找到id号为" + deleteNode.id + "的节点");
                return;
            }
            if(tmp.next.id == deleteNode.id) {
                tmp.next = tmp.next.next;
                System.out.println(deleteNode.name + "已被成功删除");
                return;
            }
            //继续遍历
            tmp = tmp.next;
        }
    }
    
    //5、遍历单链表
    public void list() {
        if (headHeroNode.next == null) {
            System.out.println("链表空，无数据");
            return;
        }else {
            //借助临时指针进行遍历
            HeroNode tmp = headHeroNode.next;
            while(tmp != null) {
                System.out.println(tmp);
                tmp = tmp.next;
            }
        }
    }
    
    
    
    //返回单链表的头部
    public HeroNode head() {
        return headHeroNode;
    }
    
    //常见面试题：--> 1、求链表中有效节点的个数 【valid:有效的】
    //需要传入一个头节点，因为每个单链表对象都不一样【长度也会有所差异】
    public int validNodes(HeroNode head) {
        //链表为空或者只有一个头节点
        if (head == null || head.next == null) {
            return 0;
        }
        //借助辅助指针进行遍历
        HeroNode tmp = head.next;
        int count = 0; //计数器
        while(tmp != null) {
            count++;
            tmp = tmp.next;
        }
        return count;
    }
    
    //2、新浪面试题：求单链表中倒数第k个节点【reciprocal：倒数】
    public HeroNode reciprocalNode(HeroNode headNode,int k) {
        //空链表
        if(headHeroNode.next == null) {
            System.out.println("链表空");
            return null;
        }
        //求出有效节点的个数
        int validNodes = validNodes(headNode);
        //k大于链表中有效数字的长度或者为非正整数
        if (k > validNodes || k <= 0) {
            System.out.println("k大于链表中有效数字的长度或者为非正整数");
            return null;
        }
        //正常遍历情况：倒数第k个：即为有效数字的个数 - k
        int index = validNodes - k;
        //借助辅助指针进行遍历
        HeroNode tmp = headNode.next;
        //定义计数器用于记住遍历了几次
        int count = 0;
        while(true) {
            if (count == index) {
                return tmp;
            }
            count++;
            tmp = tmp.next;
        }
    }
    
    //3、腾讯面试题：单链表的反转
    //思路：创建一个新的链表，每遍历到原链表中的一个节点便将其添加到新链表的头节点之后
    public void reverse(HeroNode headNode) {
        if (headNode.next == null || headNode.next.next == null) {
            System.out.println("链表为空或只有一个节点，无需反转");
            return;
        }
        HeroNode tmp = headNode.next; //临时指针遍历原来的链表
        HeroNode nextNode = tmp.next; //记住下一个将要被遍历的节点
        HeroNode reverseHead = new HeroNode(0, "", ""); //反转后的链表头
        while(true) {
            if(tmp == null) {
                break;
            }else {
                nextNode = tmp.next; //先记住下个节点
                tmp.next = reverseHead.next; //与链表头的下一个节点建立连接
                reverseHead.next = tmp; //与链表头建立连接 
                tmp = nextNode; //遍历下个节点
            }
        }
        //更换链表头，将旧的链表的头部指向新的链表头部后的第一个节点
        headNode.next = reverseHead.next;
    } 
    
    //4、百度面试题：从尾到头遍历单链表
    //方法一：反转链表，打印【缺点：破坏原来链表的结构】
    //方法二：使用栈，利用栈先进后出的特点，每遍历到一个接待你就将其push到栈中，最后pop所有的节点
    public void reverseOrderPrint(HeroNode headNode) {
        if (headNode.next == null) {
            System.out.println("链表空，无需逆序打印");
            return;
        }else {
            //定义栈容器
            Stack<HeroNode> nodes = new Stack<>();
            //辅助指针遍历单链表
            HeroNode tmp = headNode.next; //0 1 2 3 5 6 9 7
            while(tmp != null) {
                //压栈
                nodes.push(tmp);
                tmp = tmp.next;
            }
            int size = nodes.size();
            while(size != 0) {
                System.out.println(nodes.pop());
                size--;
            }
        }
    }
    
    //5、作业：合并两个有序的单链表，合并后仍然是有序的【升序】
    //思路：依次取出两个单链表中的id值进行比较，将较小值追加到新的链表的后边
    //如果一个链表已经到了末尾，则直接将另一个链表剩余的节点追加到新的链表的尾部
    public static HeroNode mergeList(HeroNode head1,HeroNode head2) {
        //如果两个单链表均为空则返回null
        if (head1 == null && head2 == null) {
            System.out.println("两个链表均为空，无需合并");
            return null;
        }else if (head1 == null) {  //如果其中一个单链表为空则返回另一个单链表即可
            return head2;
        }else if (head2 == null) {
            return head1;
        }
        //两个单链表都不为空
        //为单链表1定义一个临时指针进行遍历，并记住下一个将要被遍历到的节点
        HeroNode tmp1 = head1.next;
        HeroNode next1 = null;
        //为单链表2定义一个临时指针进行遍历，并记住下一个将要被遍历到的节点
        HeroNode tmp2 = head2.next;
        HeroNode next2 = null;
        //定义合并后的链表头
        HeroNode mergeHead = new HeroNode(0, "", "");
        //同样，新的链表的头节点不能动，借助辅助指针遍历新的链表，用于借助链表遍历到的位置，便于追加节点
        HeroNode tmpMerge = mergeHead; //此处不能为gergeHead.next,因为新链表的next为空,否则会出现空指针异常
        while(tmp1 != null && tmp2 != null) {
            if (tmp1.id < tmp2.id) { //轮到链表1
                //记住链表1中下一个将要被遍历到的节点
                next1 = tmp1.next;
                //链接到新的链表的上
                tmp1.next = tmpMerge.next;
                tmpMerge.next = tmp1;
                //临时指针向后移
                tmpMerge = tmpMerge.next;
                //继续遍历
                tmp1 = next1;
            }
            else {  //轮到链表2
                next2 = tmp2.next;
                tmp2.next = tmpMerge.next;
                tmpMerge.next = tmp2;
                //临时指针向后移
                tmpMerge = tmpMerge.next;
                tmp2 = next2;
            }
            if (tmp1 == null) {
                //如果链表1为空，则将链表2中剩余的所有节点都链接到新的链表上
                tmpMerge.next = tmp2;
                break;
            }else if(tmp2 == null) {
                tmpMerge.next = tmp1;
                break;
            }
        }
        return mergeHead;
    }
    
}

测试类中的部分测试数据：

public class SingleLinkedListDemo2 {

    public static void main(String[] args) {
        System.out.println("测试单链表添加数据:");
        HeroNode hero1 = new HeroNode(1, "曹操", "魏国");
        HeroNode hero4 = new HeroNode(4, "刘备", "蜀国");
        HeroNode hero7 = new HeroNode(7, "诸葛亮", "蜀国");
        HeroNode hero9 = new HeroNode(9, "孙权", "吴国");
        SingleLinkedList heroList = new SingleLinkedList();
        heroList.addToLast(hero1);
        heroList.addToLast(hero4);
        heroList.addToLast(hero7);
        heroList.addToLast(hero9);
        
//        heroList.addByAscend(hero1);
//        heroList.addByAscend(hero2);
//        heroList.addByAscend(hero3);
//        heroList.addByAscend(hero4);
        heroList.list();
        
//        System.out.println("修改后：--->");
//        HeroNode hero5 = new HeroNode(1, "夏侯惇", "魏国");
//        heroList.modify(hero5);
        
//        System.out.println("删除后：--->");
//        HeroNode delNode = new HeroNode(1, "曹操", "魏国");
//        heroList.delete(delNode);
        
//        System.out.println("有效节点个数为：" + heroList.validNodes(heroList.head()));
        
//        System.out.println("倒数第k个节点：-->"); 
//        System.out.println(heroList.reciprocalNode(heroList.headHeroNode, 5));
        
//        System.out.println("反转链表后：");
//        heroList.reverse(heroList.head()); 
        
//        System.out.println("逆序打印链表：");
//        heroList.reverseOrderPrint(heroList.head());
//        heroList.list();
        System.out.println("-----------------------------");
        HeroNode hero2 = new HeroNode(2, "夏侯惇", "魏国");
        HeroNode hero5 = new HeroNode(5, "马超", "蜀国");
        HeroNode hero8 = new HeroNode(8, "周瑜", "吴国");
        HeroNode hero10 = new HeroNode(10, "张飞", "蜀国");
        SingleLinkedList heroList2 = new SingleLinkedList();
        heroList2.addToLast(hero2);
        heroList2.addToLast(hero5);
        heroList2.addToLast(hero8);
        heroList2.addToLast(hero10);
        heroList2.list();
        System.out.println("合并两个有序的单链表:-->");
        HeroNode newHeroHead = SingleLinkedList.mergeList(heroList.head(), heroList2.head());
        SingleLinkedList mergeList = new SingleLinkedList();
        mergeList.addToLast(newHeroHead.next);//注：去掉头节点插入【不然会出现两个头节点】
        System.out.println("------------------");
        mergeList.list();
    }

}

由于功能较为繁多，之前测试的结果忘记保存了，在此就贴一张最后一个合并两个有序的单链表，合并后依然有序的结果把~