单项Head有序链表的实现，面试题：合并两个有序的单链表，合并之后依然有序

1.链表是以节点的方式来存储的

2.每个节点包含data域，next域：指向下一个节点。

3.链表其实就是通过next（模拟指针）使内存存储不连续的对象，变得有序。

Node：

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


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

LinkedList

 

package com.tang.arithmetic.linked;

public class SingleLinkedListFour implements LinkedList {
    private HeroNode head = new HeroNode(0, "", "");

    @Override
    public void add(HeroNode node) {
        HeroNode temp = head;

        while (true) {
            if (temp.next == null) break;
            temp = temp.next;
        }
        temp.next = node;
    }

    @Override
    public void list() {
        if (head.next == null) return;
        HeroNode temp = head.next;
        while (true) {
            if (temp == null) break;
            System.out.println(temp);
            temp = temp.next;
        }
    }

    public void addByOrder(HeroNode node) {
        HeroNode temp = head;

        boolean flag = false;

        while (true) {
            if (temp.next == null) break;
            if (temp.next.no > node.no) {
                break;
            } else if (temp.next.no == node.no) {
                flag = true;
                System.out.println("存在了");
                break;
            }
            temp = temp.next;
        }

        if (flag) {

        } else {
            node.next = temp.next;
            temp.next = node;

            return;
        }
    }


    public void update(HeroNode newNode) {
        //如果当前链表为空，调用新增方法
        if (head.next == null) add(newNode);

        HeroNode temp = head.next;

        boolean flag = false;       //标记，用于找到修改的no
        while (true) {
            if (temp == null) break;

            if (temp.no == newNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }

        if (!flag) {
            this.addByOrder(newNode);
            return;
        } else {
            temp.name = newNode.name;
            temp.nickname = newNode.nickname;
            return;
        }
    }

    /**
     * delete：
     *
     * @deleteNo
     * @Para deleteNo
     */
    public boolean deleteNo(int deleteNo) {
        if (head.next == null) return false;
        HeroNode temp = head;
        boolean flag = false;       //用于找到，需要被删除节点的前一个节点,默认没找到

        while (true) {
            if (temp.next == null) break;   //找到链表尾部，结束掉循环

            if (deleteNo == temp.next.no) {
                flag = true;    //找到退出，待删除节点的前一个节点
                break;
            }
            temp = temp.next;
        }

        if (flag) {
            temp.next = temp.next.next;
            return flag;
        }
        return flag;
    }

    public int sumNode() {
        if (head.next == null) return 0;
        int record = 0;
        HeroNode temp = head.next;

        while (true) {
            if (temp == null) break;
            record++;
            temp = temp.next;
        }

        return record;
    }


    public SingleLinkedListFour mergeTwoLinkedList(SingleLinkedListFour linkedList) {
        int i = 0;
        SingleLinkedListFour var1 = this.compareMax(linkedList);
        SingleLinkedListFour var2 = this.compareMin(linkedList);

        final int c = var2.sumNode();

        while (true) {

            if (c == i) break;
            var1.addByOrder(var2.next());

            i++;
        }

        return var1;
    }

    //从链表中取出数据，已经取出数据就会丢失
    public HeroNode next() {
        if (head.next == null) return null;
        HeroNode temp = head;
        HeroNode var = new HeroNode(temp.next.no, temp.next.name, temp.next.nickname);
        temp.next = temp.next.next;  //从链表头部开始获取数据断开与返回值的联系
        return var;
    }

    //返回最多数据的链表
    private SingleLinkedListFour compareMax(SingleLinkedListFour linkedList) {

        //如果两个链表元素相等返回当前链表
        return (this.sumNode() == linkedList.sumNode() ? 1 : 0) == 1 ? this : (this.sumNode() < linkedList.sumNode() ? linkedList : this);

    }

    //返回最少数据的链表
    private SingleLinkedListFour compareMin(SingleLinkedListFour linkedList) {
        //如果当前链表的元素数量小于传入链表元素的数量，就返回当前链表，但是可能出现两个链表元素相等的情况，如果相等返回传入链表
        return (this.sumNode() == linkedList.sumNode() ? 1 : 0) == 1 ? linkedList : (this.sumNode() > linkedList.sumNode() ? linkedList : this);

    }

}

Test：

​

    @Test
    public void LinkedLisFour() {

        SingleLinkedListFour var1 = new SingleLinkedListFour();

        var1.addByOrder(new HeroNode(2, "1", "111"));
        var1.addByOrder(new HeroNode(3, "2", "3333"));
        var1.addByOrder(new HeroNode(6, "3", "22"));


        SingleLinkedListFour var2 = new SingleLinkedListFour();
        var2.addByOrder(new HeroNode(1, "5", "5"));
        var2.addByOrder(new HeroNode(4, "xxxx", "xxxx"));
        var2.addByOrder(new HeroNode(5, "xxxx", "xxxx"));
        var2.addByOrder(new HeroNode(7, "xxxx", "xxxx"));
        var2.addByOrder(new HeroNode(8, "xxxx", "xxxx"));


       var2.mergeTwoLinkedList(var1);

        var2.list();
    }

[点击并拖拽以移动]
​

总结：

var2合并var1，但是实际代码的实现并不是按照var2来进行合并的。在底层写有两个比较算法：

compareMax：拿到最大元素的链表（因为合并调用的还是底层addByOrder方法，所以用元素最多的链表去合并元素少的链表可以相对提高效率）

compareMin：拿到最小的链表（拿到最小的数据主要是为了，上面代码中if的一个打断时机，以防空指针异常）

​