数据结构-单链表

1.单链表的介绍和内存布局

链表是一个有序的列表。

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

内存布局：

逻辑布局：

2.单链表的创建和遍历分析实现

直接添加思路：
一、添加（创建）
1、先创建一个head 头节点， 作用就是表示单链表的头
2、后面我们每添加一个节点，就直接加入到 链表的最后
二、遍历：
1、通过一个辅助变量遍历，帮助遍历整个链表，为null 终止

按顺序添加节点思路：
1、首先找到新添加的节点的位置, 是通过辅助变量temp（这里需要遍历到指定节点的上一个几点，才能进行修改）, 通过遍历来搞定
2、新的节点 ，新节点.next = temp.next
3、将temp.next = 新节点 ，新的节点

删除节点思路：
1、我们先找到 需要删除的这个节点的前一个节点 temp
2、temp.next = temp.next.next
3、被删除的节点，将不会有其它引用指向，会被垃圾回收机制回收

HeroNode结构如下：

class HeroNode {
	int no;
	String name;
	String nickName;
	HeroNode next;
}

2 代码实现：

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

        //创建要给链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();

        //加入
        //singleLinkedList.add(hero1);
        //singleLinkedList.add(hero4);
        //singleLinkedList.add(hero2);
        //singleLinkedList.add(hero3);
        
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        HeroNode updateHero1 = new HeroNode(1, "宋江", "及时雨111");
        singleLinkedList.update(updateHero1);
        
		singleLinkedList.delete(1);
        
        singleLinkedList.show();
    }
}

class SingleLinkedList {
    //定义一个头节点，不用动，不存数据
    HeroNode head = new HeroNode(0,"","");

    /**
     * 往链表中添加节点,不考虑排序，直接插入
     * @param node
     */
    public void add(HeroNode node) {
        //定义一个辅助变量，用于遍历链表，并从头节点开始
        HeroNode temp = head;
        while (true) {
            //找到最后一个节点
            if (temp.next == null) {
                break;
            }
            //没找到继续遍历下一个
            temp = temp.next;
        }
        //找到之后呢，将新增的加入到最后
        temp.next = node;
    }

    /**
     * 按照编号顺序加入,考虑no排序
     * @param node
     */
    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;
                break;
            }
            //注意后移
            temp = temp.next;
        }
        //找到节点，修改next指向
        if (flag) {
            // 不能添加，说明编号已经存在
            System.out.printf("准备插入的英雄的编号 %d 已经存在了, 不能加入\n", node.no);
        } else {
            //注意顺序
            node.next = temp.next;
            temp.next = node;
        }
    }

    /**
     * 按照newHeroNode中的no对找到的no进行修改数据
     * @param newHeroNode
     */
    public void update(HeroNode newHeroNode) {
        // 判空
        if(head.next == null) {
            System.out.println("链表为空~~");
            return;
        }
        //辅助变量
        HeroNode temp = head.next;
        //是否找到需要修改的no
        boolean flag = false;
        while (true) {
            //遍历完了
            if (temp == null) {
                break;
            }
            //找到no相等的节点
            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】要修改的英雄",newHeroNode.no);
        }
    }
    /**
     * 删除指定no节点数据
     * @param 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) {
            //找到的是当前节点上一个节点，并将这个节点的next指向被删除节点的下一个
            temp.next = temp.next.next;
        } else {
            System.out.printf("没有找到排行为【%d】要修改的英雄",no);
        }
    }

    /**
     * 遍历单列表并打印
     */
    public void show() {
        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;
        }
    }
}


//定义HeroNode ， 每个HeroNode 对象就是一个节点
class HeroNode {
    //排序
    public int no;
    //姓名
    public String name;
    //别名
    public String nickName;
    //next节点
    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 + '\'' +
                '}';
    }
}

3.单链表经典面试题分析

1.求单链表中有效节点个数
2.查找单链表中倒数第k个节点
3.单链表的反转
4.从尾到头打印单链表
5.合并两个有序链表，合并后的链表依然有序

代码：

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        //先创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(3, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(5, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(7, "林冲", "豹子头");


        HeroNode hero5 = new HeroNode(2, "宋江1", "及时雨1");
        HeroNode hero6 = new HeroNode(4, "卢俊义1", "玉麒麟1");
        HeroNode hero7 = new HeroNode(6, "吴用1", "智多星1");
        HeroNode hero8 = new HeroNode(8, "林冲1", "豹子头1");

        //创建要给链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        SingleLinkedList singleLinkedList1 = new SingleLinkedList();

        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);

        singleLinkedList1.addByOrder(hero5);
        singleLinkedList1.addByOrder(hero6);
        singleLinkedList1.addByOrder(hero7);
        singleLinkedList1.addByOrder(hero8);

        //System.out.println(SingleLinkedList.getLength(singleLinkedList.getHeadNode()));

        //System.out.println(SingleLinkedList.findLastIndexNode(singleLinkedList.getHeadNode(),1));
        //SingleLinkedList.reverseList(singleLinkedList.getHeadNode());
        //SingleLinkedList.reversePrint(singleLinkedList.getHeadNode());

        singleLinkedList.show();
        singleLinkedList1.show();

        singleLinkedList.mergeLinkedListByOrder(singleLinkedList.getHeadNode(), singleLinkedList1.getHeadNode());
    }
}

class SingleLinkedList {
    //定义一个头节点，不用动，不存数据
    HeroNode head = new HeroNode(0,"","");

    /**
     * 获取当前链表的头节点
     * @return
     */
    public HeroNode getHeadNode() {
        return head;
    }

    /**
     * 题目2：查找单链表倒数第k个节点
     * @param head
     * @param index
     * @return
     */
    public static HeroNode findLastIndexNode(HeroNode head, int index) {
        if (head.next == null) {
            return null;
        }
        HeroNode temp = head.next;
        //第一次遍历获取长度
        int length = getLength(head);

        // 先做一个index的校验
        if (index <= 0 || index > length) {
            // 查找的位置不能大过总长
            return null;
        }
        //(size - index)为倒数第index个，直接遍历size-index次就是倒是第index个
        for (int i = 0; i< (length - index); i++) {
            temp = temp.next;
        }
        //返回遍历的最后节点
        return temp;
    }

    /**
     * 题目1，获取有效数据个数
     * @param head
     * @return
     */
    public static int getLength(HeroNode head) {
        int length = 0;
        HeroNode temp = head.next;
        while(true) {
            if (temp == null) {
                break;
            }
            length++;
            temp = temp.next;
        }
        return length;
    }

    /**
     * 题目3：单链表的反转
     * @param head
     */
    public static void reverseList(HeroNode head) {
        // 若链表为空，或者只有一个则不需要反转
        if (head.next == null || head.next.next == null) {
            return;
        }
        //定义一个新的头结点
        HeroNode newHead = new HeroNode(0,"","");
        //当前节点
        HeroNode cur = head.next;
        //用于暂存当前节点的下一个节点，因为当前节点放入新的之后next会改变，这样后移的数据就变化了
        HeroNode next = null;

        while(cur != null) {
            //暂存当前节点下一个节点信息
            next = cur.next;
            //为什么上一步暂存，这里可以找到答案，这里将当前节点的next进行了改变，而后面需要对cur进行后移
            cur.next = newHead.next;
            //将取下来的节点放入新的头里面
            newHead.next = cur;
            //继续往下
            cur = next;
        }

        //将old的头节点指向新的反转后的
        head.next = newHead.next;

    }

    /**
     * 题目4：从尾到头打印单链表，这里如果使用反转再打印，会破坏原始结构，采用栈结构来做
     * @param head
     */
    public static void reversePrint(HeroNode head) {
        if (head.next == null) {
            return;
        }
        //定义一个栈结构
        Stack<HeroNode> stack = new Stack<>();
        HeroNode temp = head.next;
        while(true) {
            if (temp == null) {
                break;
            }
            //将节点压栈
            stack.push(temp);
            //注意后移
            temp = temp.next;
        }
        while (stack.size() > 0) {
            //出栈即反转打印
            System.out.println(stack.pop());
        }
    }

    /**
     * 题目5：合并两个有序链表，合并后依然有序
     * @param head1
     * @param head2
     * @return
     */
    public HeroNode mergeLinkedListByOrder(HeroNode head1, HeroNode head2) {
        if (head1.next == null) {
            return head2;
        }
        if (head2.next == null) {
            return head1;
        }
        //定义一个新的头结点
        HeroNode newHead = new HeroNode(0,"","");
        //定义一个新的头结点的辅助变量，只想当前加入的节点
        HeroNode cur = newHead;
        //两个链表各自的起始节点
        HeroNode temp1 = head1.next;
        HeroNode temp2 = head2.next;
        //遍历两个链表，因为是有序的，便利过程中比较两个的大小，决定下一个位置
        while (temp1 != null && temp2 != null) {
            if (temp1.no < temp2.no) {
                //链表1小，加入新链表，并后移
                cur.next = temp1;
                temp1 = temp1.next;
            } else {
                //链表2小，加入新链表，并后移
                cur.next = temp2;
                temp2 = temp2.next;
            }
            //新链表后移
            cur = cur.next;
        }
        //遍历完了，把剩下的有序结果直接放入新链表
        if (temp1 != null) {
            cur.next = temp1;
        }
        if (temp2 != null) {
            cur.next = temp2;
        }
        //返回新链表
        return newHead;
    }

    /**
     * 往链表中添加节点
     * @param node
     */
    public void add(HeroNode node) {
        //定义一个辅助变量，用于遍历链表，并从头节点开始
        HeroNode temp = head;
        while (true) {
            //找到最后一个节点
            if (temp.next == null) {
                break;
            }
            //没找到继续遍历下一个
            temp = temp.next;
        }
        //找到之后呢，将新增的加入到最后
        temp.next = node;
    }

    /**
     * 按照编号顺序加入
     * @param node
     */
    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;
                break;
            }
            //注意后移
            temp = temp.next;
        }
        //找到节点，修改next指向
        if (flag) {
            // 不能添加，说明编号已经存在
            System.out.printf("准备插入的英雄的编号 %d 已经存在了, 不能加入\n", node.no);
        } else {
            //注意顺序
            node.next = temp.next;
            temp.next = node;
        }
    }

    /**
     * 按照newHeroNode中的no对找到的no进行修改数据
     * @param newHeroNode
     */
    public void update(HeroNode newHeroNode) {
        // 判空
        if(head.next == null) {
            System.out.println("链表为空~~");
            return;
        }
        //辅助变量
        HeroNode temp = head.next;
        //是否找到需要修改的no
        boolean flag = false;
        while (true) {
            //遍历完了
            if (temp == null) {
                break;
            }
            //找到no相等的节点
            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】要修改的英雄",newHeroNode.no);
        }
    }

    /**
     * 删除指定no节点数据
     * @param 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) {
            //找到的是当前节点上一个节点，并将这个节点的next指向被删除节点的下一个
            temp.next = temp.next.next;
        } else {
            System.out.printf("没有找到排行为【%d】要修改的英雄",no);
        }
    }

    /**
     * 遍历单列表并打印
     */
    public void show() {
        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;
        }
    }
}


//定义HeroNode ， 每个HeroNode 对象就是一个节点
class HeroNode {
    //排序
    public int no;
    //姓名
    public String name;
    //别名
    public String nickName;
    //next节点
    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 + '\'' +
                '}';
    }
}