数据结构——单链表

数据结构——单链表

链表的介绍和操作：

经典面试题：

1.单链表反转
思路分析：

1.先定义一个结点reverseHead;
2.遍历原来的链表，每遍历一个结点，就将其取出放在新链表的前端；
3.将原链表头结点指向新链表head.next = reverseHead.next
2.单链表的逆序打印
3.合并两个有序单链表，合并后仍然有序；

代码实现：

    public static void reversetList(HeroNode head) {
    //如果当前链表为空，或者只有一个节点，无需反转，直接返回
        if (head.next == null || head.next.next == null) {
            return;
        }
    //定义一个辅助的指针(变量)，帮助我们遍历原来的链表
        HeroNode cur = head.next;
        HeroNode next = null;// 指向当前节点[cur]的下一个节点
        HeroNode reverseHead = new HeroNode(0, "", "");
    //遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表 reverseHead 的最前端
    //动脑筋
        while (cur != null) {
            next = cur.next;//先暂时保存当前节点的下一个节点，因为后面需要使用
            cur.next = reverseHead.next;//将 cur 的下一个节点指向新的链表的最前端
            reverseHead.next = cur; //将 cur 连接到新的链表上
            cur = next;//让 cur 后移
        }
    //将 head.next 指向 reverseHead.next , 实现单链表的反转
        head.next = reverseHead.next;
    }

2.单链表的逆序打印
思路分析：

1）可以先将链表反转，但是这样会改变链表结构；
2）使用栈先进先出的特性;
3) 使用递归

代码实现：

使用栈：

    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 后移，这样就可以压入下一个节点
        }
        //将栈中的节点进行打印,pop 出栈
        while (stack.size() > 0) {
            System.out.println(stack.pop()); //stack 的特点是先进后出
        }
    }

使用递归

    // 逆序打印（递归）
    public static void reversePrint(HeroNode head) {
        if (head.next == null) {
            return;
        }
        HeroNode temp = head.next;
        reversePrint(temp);
        System.out.println(temp.name);
    }

3.合并两个有序链表，且合并后仍然有序
思路分析：
1）使用迭代
创建一个新链表和一个临时变量，迭代两个有序链表，判断较小值并添加到新链表上，最后返回新链表；
2）使用递归
分析返回的条件，这里是链表为空时。

代码实现：
使用迭代：

    // 合并两个有序的单链表，合并之后依然有序（迭代）
    public static HeroNode mergeLinkedList(HeroNode node1, HeroNode node2) {
        HeroNode mergeHead = new HeroNode(0,"","");
        // 创建临时变量。因为不能改变mergehead！！！
        HeroNode temp = mergeHead;
        while (node1 != null && node2 != null) {
            if (node1.no <= node2.no) {
                temp.next = node1;
                node1 = node1.next;
            } else {
                temp.next = node2;
                node2 = node2.next;
            }
            temp = temp.next;
        }
        temp.next = node1 == null ? node2 : node1;
        return mergeHead.next;
    }

使用递归：

    // 合并两个有序的单链表，合并之后依然有序（递归）
    public static HeroNode mergeLinkedList2(HeroNode node1, HeroNode node2) {
        if (node1 == null) {
            return node2;
        }
        if (node2 == null) {
            return node1;
        }
        if (node1.no <= node2.no) {
            node1.next = mergeLinkedList2(node1.next, node2.next);
            return node1;
        } else {
            node2.next = mergeLinkedList2(node1, node2.next);
            return node2;
        }
    }