数据结构学习日记：合并两个有序的单链表，合并之后依然有序

测试类主方法中的合并方法程序：

    public static void mergeList(HeroNode head1, HeroNode head2) {
        //传入两个需要合并的单链表的头节点，将s2插入s1
        if (head1.next == null || head2.next == null) {
            System.out.println("有链表为空，无需合并");
            return;
            //如果两个单链表中有空链表，无需合并
        }
        HeroNode next = null;
        //定义储存中间节点的节点
        HeroNode temp = head2.next;
        while (temp != null) {
            HeroNode temp2 = head1.next;
            boolean flag = false;
            //定义一个判别是否找到插入位置的标志
            while (true) {
                if (temp2.next == null) {
                    flag = true;
                    //如果查找到了单链的末尾，可以后插
                    break;
                }
                if (temp2.next.no == temp.no) {
                    break;
                    //如果有相同的节点，不能插入，继续查找
                }
                if (temp2.next.no > temp.no) {
                    flag = true;
                    //如果插入的节点序号小于某节点序号，则应该在此节点后面插入
                    break;
                }
                temp2 = temp2.next;
                //节点后移
            }
            if (flag) {
                next = temp.next;
                temp.next = temp2.next;
                //插入的节点指向原链表该节点的下一个节点
                temp2.next = temp;
                //原链该节点指向插入的节点
                temp = next;
                //通过中间变量使得能够继续遍历
            }
        }
    }

可以实现的完整程序：

package sjjg;

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        HeroNode hero1 = new HeroNode(1, "chenyi1", "luzhou");
        HeroNode hero2 = new HeroNode(2, "chenyi2", "beijing");
        HeroNode hero3 = new HeroNode(3, "chenyi3", "shenzhen");
        HeroNode hero4 = new HeroNode(4, "chenyi4", "yunnan");
        HeroNode hero5 = new HeroNode(5, "chenyi5", "guangzhou");
        HeroNode hero6 = new HeroNode(6, "chenyi6", "shanghai");
        HeroNode hero7 = new HeroNode(7, "chenyi7", "jiangsu");
        HeroNode hero8 = new HeroNode(8, "chenyi8", "sichuan");
        HeroNode hero9 = new HeroNode(9, "chenyi9", "tianjin");
/*        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);
        HeroNode newHeroNode = new HeroNode(4, "xiaoxu", "kunming");
        singleLinkedList.updata(newHeroNode);
        singleLinkedList.delete(1);
        singleLinkedList.list();
        System.out.printf("链表的个数为%d\n", getLength(singleLinkedList.getHead()));
        getRk(singleLinkedList.getHead(), 4);
        reverseList(singleLinkedList.getHead());
        singleLinkedList.list();*/
        SingleLinkedList s1 = new SingleLinkedList();
        SingleLinkedList s2 = new SingleLinkedList();
        s1.addByOrder(hero1);
        s1.addByOrder(hero3);
        s1.addByOrder(hero7);
        s1.addByOrder(hero9);
        s1.addByOrder(hero4);
//        s1.addByOrder(hero8);
        s1.list();
//        System.out.println(getLength(s1.getHead()));
        s2.addByOrder(hero2);
        s2.addByOrder(hero5);
        //       s2.addByOrder(hero4);
        s2.addByOrder(hero6);
        s2.addByOrder(hero8);
        System.out.println("----分割线----");
        s2.list();
        System.out.println("----分割线----");
        mergeList(s1.getHead(), s2.getHead());
        s1.list();

    }

    public static void mergeList(HeroNode head1, HeroNode head2) {
        //传入两个需要合并的单链表的头节点，将s2插入s1
        if (head1.next == null || head2.next == null) {
            System.out.println("有链表为空，无需合并");
            return;
            //如果两个单链表中有空链表，无需合并
        }
        HeroNode next = null;
        //定义储存中间节点的节点
        HeroNode temp = head2.next;
        while (temp != null) {
            HeroNode temp2 = head1.next;
            boolean flag = false;
            //定义一个判别是否找到插入位置的标志
            while (true) {
                if (temp2.next == null) {
                    flag = true;
                    //如果查找到了单链的末尾，可以后插
                    break;
                }
                if (temp2.next.no == temp.no) {
                    break;
                    //如果有相同的节点，不能插入，继续查找
                }
                if (temp2.next.no > temp.no) {
                    flag = true;
                    //如果插入的节点序号小于某节点序号，则应该在此节点后面插入
                    break;
                }
                temp2 = temp2.next;
                //节点后移
            }
            if (flag) {
                next = temp.next;
                temp.next = temp2.next;
                //插入的节点指向原链表该节点的下一个节点
                temp2.next = temp;
                //原链该节点指向插入的节点
                temp = next;
                //通过中间变量使得能够继续遍历
            }
        }
    }

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

    public static void getRk(HeroNode head, int k) {
        int length = getLength(head);
        HeroNode temp = head.next;
        int Nk = length - k;
        boolean flag = false;
        while (true) {
            if (k > length) {
                break;
            }
            if (temp == null) {
                System.out.println("链表为空，无法获取");
                break;
            }
            if (Nk == 0) {
                flag = true;
                break;
            }
            Nk--;
            temp = temp.next;
        }
        if (flag) {
            System.out.println(temp);
        } else {
            System.out.printf("无法找到倒数第%d个节点\n", k);
        }
    }

    public static void reverseList(HeroNode head) {
        HeroNode reverseHead = new HeroNode(0, "", "");
        HeroNode temp = head.next;
        HeroNode next = null;
        if (head.next == null || head.next.next == null) {
            System.out.println("链表为空，无法反转");
            return;
        }
        while (temp != null) {
            next = temp.next;
            temp.next = reverseHead.next;
            reverseHead.next = temp;
            temp = next;
        }
        head.next = reverseHead.next;
    }
}

//定义节点
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 + '\'' +
                '}';
    }
}

class SingleLinkedList {
    private HeroNode head = new HeroNode(0, "", "");

    public HeroNode getHead() {
        return head;
    }

    public void add(HeroNode heroNode) {
        HeroNode temp = head;
        while (true) {
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        temp.next = heroNode;
    }

    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.next;
        }
//        System.out.printf("此链表的个数为%d",count);
    }

    public void addByOrder(HeroNode heroNode) {
        HeroNode temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no > heroNode.no) {
                break;
            } else if (temp.next.no == heroNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            System.out.printf("你输入的节点%d已存在\n", heroNode.no);
        } else {
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    public void updata(HeroNode newHeroNode) {
        HeroNode temp = head.next;
        boolean flag = false;
        while (true) {
            if (temp == null) {
                break;
            }
            if (temp.no == newHeroNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        } else {
            System.out.printf("没有找到你想要修改的节点%d\n", newHeroNode.no);
        }
    }

    public void delete(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;
        }
        if (flag) {
            temp.next = temp.next.next;
        } else {
            System.out.printf("没有找到你想删除的节点%d\n", no);
        }
    }

e.g.