数据结构-链表

标签：尾插法   拼接   特殊   else   假设   序号   双向   逆序   链式存储结构   

单链表练习

介绍

1. 链表以结点的方式储存，链式存储

2. 每个结点包含data域，next域

3. 链表的结点可以是连续的，也可以是不连续的

4. 链表分类

   • 带头结点的链表

     

   • 没有头结点的链表

应用实例

题目：使用带head头的单冋链表实现ˉ水浒英雄排行榜管理完成对英雄人物的増删改査操作。

功能需求

• 在添加英雄时，直接添加到链表的尾部

• 在添加英雄时，根据排名将英雄插入到指定位置（如果有这个排名，则添加失败，并给出提示）

• 修改节点数据

• 删除节点

代码实现

单链表代码

package com.linkedlist;

public class SingleLinkedList {
    // 先初始化一个头结点，头结点是寻找链表开始，不要动它
    private HeroNode head = new HeroNode(0, "", "");

    public HeroNode getHead() {
        return head;
    }

    public void setHead(HeroNode head) {
        this.head = head;
    }

    /**
     * 头插法添加新节点
     */
    public void addHead(HeroNode heroNode) {
        heroNode.next = head.next;
        head.next = heroNode;
    }

    /**
     * 尾插法添加新节点
     * @param heroNode 新节点
     */
    public void add(HeroNode heroNode) {
        // 1.首先遍历到尾结点
        HeroNode temp = head;
        while (temp.next != null) {
            temp = temp.next;
        }
        // 2.将尾结点的next指向新节点
        temp.next = heroNode;
    }

    /**
     * 根据排名插入数据
     * @param heroNode 新节点
     */
    public void addByOrder(HeroNode heroNode) {
        // 1.首先找到新节点的插入位置
        HeroNode temp = head;
        // 如果找到尾结点还没有找到合适的位置，则尾插到最后
        while (temp.next != null && temp.next.no <= heroNode.no) {
            temp = temp.next;
            if (temp.no == heroNode.no) {
                System.out.println(heroNode.name+"已存在,不可添加");
                return;
            }
        }
        // 2.新节点指向后节点
        heroNode.next = temp.next;
        // 3.原节点指向新节点
        temp.next = heroNode;
    }

    /**
     * 根据编号更新节点数据
     */
    public void update(HeroNode heroNode) {
        // 1.首先找到新节点的插入位置
        HeroNode temp = head;
        while (temp.next != null && temp.no != heroNode.no) {
            temp = temp.next;
        }
        // 如果跳出循环还没有匹配，就是找不到对应的节点
        if (temp.no != heroNode.no) {
            System.out.println("该编号不存在");
        } else {
            temp.name = heroNode.name;
            temp.nickname = heroNode.nickname;
        }
    }

    /**
     * 删除节点
     */
    public void delete(int no) {
        // 首先找到删除节点的【前一个】节点
        HeroNode temp = head;
        while (temp.next != null && temp.next.no != no) {
            temp = temp.next;
        }
        // 如果没没有遍历到最后一个节点说明找到了匹配的节点
        if (temp.next != null) {
            // 跳过匹配节点的链接
            temp.next = temp.next.next;
        } else {
            System.out.println(no + "节点不存在");
        }
    }
    /**
     * 打印链表信息
     */
    public void list() {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        // 临时变量遍历
        HeroNode temp = head;
        while (temp.next != null) {
            temp = temp.next;
            System.out.println(temp.toString());
        }
    }

}

/**
 * 定义一个节点
 */
class HeroNode {
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;


    public HeroNode() {
    }

    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 + ‘\‘‘ +
                ‘}‘;
    }
}

测试代码

package com.linkedlist;

public class Application {
    public static void main(String[] args) {
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "李逵", "黑旋风");
        HeroNode hero3 = new HeroNode(3, "林冲", "豹子头");

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

        // 头插法 头插和尾插没有做存在判断，可能会出现死循环。
//        singleLinkedList.addHead(hero1);
//        singleLinkedList.addHead(hero2);
//        singleLinkedList.addHead(hero3);

        // 尾插法添加节点
//        singleLinkedList.add(hero1);
//        singleLinkedList.add(hero3);
//        singleLinkedList.add(hero2);


        // 按照序号排序添加节点
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero3);

        // 显示所有数据
        singleLinkedList.list();

        // 修改节点数据
        HeroNode newNode = new HeroNode(1, "小宋", "下大雨");
        singleLinkedList.update(newNode);

        System.out.println("=====修改节点后=====");
        singleLinkedList.list();

        // 删除节点数据
        System.out.println("=====删除过程=====");
        singleLinkedList.delete(1);
        singleLinkedList.delete(3);
        singleLinkedList.delete(4);
        System.out.println("=====删除节点后=====");
        singleLinkedList.list();
    }
}

练习

1. 求单链表有效节点的个数
   • 从第一个有效节点开始后移，计数
2. 【新浪】查找单链表倒数第k个数据
   • 先获取有效节点个数
   • 再从第一个有效节点后移size-k次
3. 【腾讯】反转单链表
   • 创建一个新的头节点（看作临时链表）
   • 遍历原链表依次将节点用头插法存到新头节点（记得储存当前节点的下一个节点next）
   • 原头节点指向新头节点的第一个有效节点
4. 【百度】从尾到头打印单链表（方式一：反向遍历 方式二：Stack）
   • 调用栈的API，遍历单链表将节点压入栈中
   • 出栈打印
5. 合并两个单链表，合并之后仍然有序
   • 首先比较两链表的长度，将短的链表拼接到长的链表
   • 遍历短的链表，调用长链表按编号插入的方法将节点插入

练习代码实现

package com.linkedlist;

import java.util.Stack;

public class practice {
    public static void main(String[] args) {
        // 创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();

        // 按照序号排序添加节点
        singleLinkedList.addByOrder(new HeroNode(2, "李逵", "黑旋风"));
        singleLinkedList.addByOrder(new HeroNode(1, "宋江", "及时雨"));
        singleLinkedList.addByOrder(new HeroNode(3, "林冲", "豹子头"));

        // 显示链表当前情况
        singleLinkedList.list();

        // 1.求单链表有效节点的个数
        System.out.println("1.当前链表有效节点个数为：" + getSingleLinkedListLength(singleLinkedList));

        // 2.【新浪】查找单链表倒数第k个数据
        // 假设链表数据 头 1 2 3 ，有效长度：3 ， 找倒数第1个数据 ，只需要从第一个节点向后移3-1次
        HeroNode res = findLastIndexNode(singleLinkedList, 1);
        System.out.println("2.res=" + res);

        // 3.【腾讯】反转单链表
//        reversalSingleLinkedList(singleLinkedList);
//        singleLinkedList.list();

        // 4.【百度】从尾到头打印单链表（方式一：反向遍历 方式二：Stack）
        System.out.println("4.逆序打印单链表，不破坏原链表");
        singleLinkedList.list();
        System.out.println("逆序打印");
        reversalPrint(singleLinkedList);

        // 5. 合并两个单链表，合并之后仍然有序。
        SingleLinkedList list1 = new SingleLinkedList();
        SingleLinkedList list2 = new SingleLinkedList();
        list1.addByOrder(new HeroNode(2, "李逵", "黑旋风"));
        list1.addByOrder(new HeroNode(1, "宋江", "及时雨"));
        list1.addByOrder(new HeroNode(3, "林冲", "豹子头"));

        list2.addByOrder(new HeroNode(4, "吴用", "智多星"));
        list2.addByOrder(new HeroNode(1, "宋江", "及时雨"));
//        list2.addByOrder(new HeroNode(5, "宋江", "及时雨"));
//        list2.addByOrder(new HeroNode(6, "宋江", "及时雨"));
//        list2.addByOrder(new HeroNode(7, "宋江", "及时雨"));

        System.out.println("+++++++二合一+++++++++++");
        System.out.println("链表1原数据");
        list1.list();
        System.out.println("链表2原数据");
        list2.list();

        boolean list1Long = true;
        // 如果链表1的长度大于链表2长度，则将链表2合并到链表1，调用链表的按编号插入方法
        if (getSingleLinkedListLength(list1) > getSingleLinkedListLength(list2)) {
            combineSingleLinkedList(list1, list2);
        } else {
            list1Long = false;
            combineSingleLinkedList(list2, list1);
        }
        System.out.println("合并后");
        if (list1Long) {
            list1.list();
        } else {
            list2.list();
        }
    }

    /**
     * 将链表2合并到链表1
     * @param list1 1
     * @param list2 2
     */
    private static void combineSingleLinkedList(SingleLinkedList list1, SingleLinkedList list2) {
        // 如果链表2 无数据直接返回
        if (list2 == null || list2.getHead() == null) {
            return;
        }
        HeroNode cur2 = list2.getHead().next;
        HeroNode next2 = null;

        while (cur2 != null) {
            next2 = cur2.next;
            list1.addByOrder(cur2);
            cur2 = next2;
        }
    }

    private static void reversalPrint(SingleLinkedList singleLinkedList) {
        if (singleLinkedList == null || singleLinkedList.getHead() == null) {
            System.out.println("链表为空");
            return;
        }
        Stack<HeroNode> heroNodes = new Stack<>();
        HeroNode cur = singleLinkedList.getHead().next;
        while (cur != null) {
            heroNodes.push(cur);
            cur = cur.next;
        }

        while (!heroNodes.empty()) {
            System.out.println(heroNodes.pop());
        }
    }

    public static int getSingleLinkedListLength(SingleLinkedList list) {
        if (list == null || list.getHead().next == null) {
            return 0;
        }
        // 因为头结点不算有效数据，将它视为第0个，后移一次加一个
        HeroNode cur = list.getHead();
        int length = 0;
        while (cur.next != null) {
            cur = cur.next;
            length++;
        }
        return length;
    }

    private static HeroNode findLastIndexNode(SingleLinkedList singleLinkedList, int n) {
        if (singleLinkedList == null || singleLinkedList.getHead() == null) {
            return null;
        }
        // 获取链表的有效长度
        int size = getSingleLinkedListLength(singleLinkedList);
        // 检查查找的下标的有效性
        if (n <= 0 || n > size) {
            return null;
        }
        // 从第一个结点开始移动，移动size - n 次
        HeroNode cur = singleLinkedList.getHead().next;
        for (int i = 0; i < size - n; i++) {
            cur = cur.next;
        }
        return cur;
    }

    private static void reversalSingleLinkedList(SingleLinkedList list) {
        // 只有一个节点时也不需要反转
        if (list == null || list.getHead().next == null || list.getHead().next.next == null) {
            return;
        }
        // 定义一个新的头节点，带领新队伍
        HeroNode newHead = new HeroNode();
        // 从第一个节点开始遍历
        HeroNode cur = list.getHead().next;
        // 记录后一个节点
        HeroNode next = null;

        while (cur != null) {
            next = cur.next;
            cur.next = newHead.next;
            newHead.next = cur;
            cur = next;
        }

        list.getHead().next = newHead.next;
    }
}

循环链表

循环链表：将单链表中终端结点的指针端由空指针改为指向头结点，就使整个单链表形成个环。

其实就是头尾相连的单链表。

应用场景（约瑟夫问题）

Joseph问题为：设编号为1，2，…n的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m的那个人出列，

它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。

解决思路

实现代码

package com.linkedlist;

public class Joseph {
    public static void main(String[] args) {
        //Joseph问题为：
        // 设编号为1，2，…n的n个人围坐一圈，约定编号为k（1<=k<=n）的人
        // 从1开始报数，数到m的那个人出列，
        // 它的下一位又从1开始报数，数到m的那个人又出列
        // 依次类推，直到所有人出列为止，由此产生一个出队编号的序列。
        // 例如：5个人，从1号开始报数，报到2出列
        start(5, 1, 2);
    }

    private static void start(int n, int k, int m) {
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        // 添加n个小朋友 1 2 3
        for (int i = 1; i <= n; i++) {
            Node node = new Node(i);
            circleSingleLinkedList.add(node);
        }
        // 约定k号开始报数，进行链表偏移
        circleSingleLinkedList.offset(k);

        // 数到2，依次出队
        System.out.print("出列顺序为：");
        for (int i = 0; i < n; i++) {
            circleSingleLinkedList.out(m);
        }
    }
}

/**
 * 单向循环链表
 */
class CircleSingleLinkedList {
    // 创建一个头结点
    private Node first;

    public void add(Node node) {
        if (first == null) {
            first = node;
            first.setNext(node);
        }
        Node temp = first;
        while (temp.getNext() != first) {
            temp = temp.getNext();
        }
        temp.setNext(node);
        // 循环链表相比于单向链表多了最后一个节点指向头节点。
        node.setNext(first);
    }

    public void offset(int k) {
        if (first == null) {
            System.out.println("空？");
            return;
        }
        // 第一个节点向后偏移
        for (int i = 0; i < k - 1; i++) {
            first = first.getNext();
        }

    }

    public void out(int k) {
        // 校验移动值
        if (k < 1) {
            System.out.println("k异常");
            return;
        }
        if (first == null) {
            System.out.println("没人了");
            return;
        }

        Node temp = first;
        // 首先将temp指向最后一个节点
        while (temp.getNext() != first) {
            temp = temp.getNext();
        }

        // 从1开始报数，报数到k
        for (int i = 0; i < k - 1; i++) {
            first = first.getNext();
            temp = temp.getNext();
        }
        System.out.print(first.getNo() + "\t");
        first = first.getNext();
        temp.setNext(first);
    }

    public void list() {
        if (first == null) {
            System.out.println("链表为空");
            return;
        }

        Node temp = first;
        // 先打印再判断
        do {
            System.out.println(temp.getNo());
            temp = temp.getNext();
        } while (temp != first);

    }
}

/**
 * 单向链表的节点
 */
class Node {
    private int no;
    private Node next;

    public Node() {
    }

    public Node(int no) {
        this.no = no;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
}

双向链表

使用单链表时的缺点分析：

• 查找方向只能是一个方向，不能往前查找
• 不能自我删除，需要借助临时结点

介绍

双向链表其实就是在单向链表的基础上添加的一个指向父结点的变量pre

双链表实现代码

package com.linkedlist;

/**
 * 定义一个节点
 */
class HeroNode2 {
    public int no;
    public String name;
    public String nickname;
    public HeroNode2 pre;
    public HeroNode2 next;

    public HeroNode2() {
    }

    public HeroNode2(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 + ‘\‘‘ +
                ‘}‘;
    }
}

/**
 * 双向链表，pre指向前一个节点，next指向后一个节点
 * 其实就是在单链表的基础上加了pre
 */
public class DoubleLinkedList {
    private HeroNode2 head = new HeroNode2();

    // 获得双向链表的头节点
    public HeroNode2 getHead() {
        return head;
    }

    public void setHead(HeroNode2 head) {
        this.head = head;
    }

    /**
     * 遍历链表
     */
    public void list() {
        if (head.next == null) {
            System.out.println("双向链表为空");
            return;
        }
        HeroNode2 temp = head.next;
        while (temp != null) {
            System.out.println(temp);
            temp = temp.next;
        }
    }

    /**
     * 逆向遍历链表
     */
    public void reversalList() {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        // 临时变量遍历
        HeroNode2 temp = head;
        // 先从头跑到尾
        while (temp.next != null) {
            temp = temp.next;
        }
        // 再从尾开始往前打印
        while (temp.pre != null) {
            System.out.println(temp);
            temp = temp.pre;
        }
    }

    /**
     * 添加节点
     */
    public void add(HeroNode2 node) {
        HeroNode2 temp = head;
        // 首先找到最后一个节点
        while (temp.next != null) {
            temp = temp.next;
        }
        // 双向链接
        temp.next = node;
        node.pre = temp;
    }

    /**
     * 根据编号顺序添加
     * @param heroNode 添加的节点
     */
    public void addByOrder(HeroNode2 heroNode) {
        // 1.首先找到新节点的插入位置
        HeroNode2 temp = head.next;
        // 如果找到尾结点还没有找到合适的位置，则尾插到最后
        while (temp != null && temp.no <= heroNode.no) {
            if (temp.no == heroNode.no) {
                System.out.println(heroNode.name+"已存在,不可添加");
                return;
            }
            temp = temp.next;
        }
        if (temp == null) {
            // 如果遍历到最后还没有合适的位置则变为尾插
            add(heroNode);
        } else {
            // 2.新节点指向当前的前节点和当前节点
            heroNode.pre = temp.pre;
            heroNode.next = temp;
            // 3.前后两节点指向新节点
            temp.pre.next = heroNode;
            temp.pre = heroNode;
        }

    }

    /**
     * 修改
     */
    public void update(HeroNode2 node) {
        if (head.next == null) {
            System.out.println("双向链表为空");
            return;
        }
        HeroNode2 temp = head.next;
        // 首先遍历链表，匹配到就停止循环
        while (temp != null && temp.no != node.no) {
            temp = temp.next;
        }
        // 匹配则找到 (空链有问题)
        if (temp != null) {
            temp.name = node.name;
            temp.nickname = node.nickname;
        } else {
            System.out.println("找不到修改节点");
        }

    }

    /**
     * 删除节点
     */
    public void delete(int no) {
        if (head.next == null) {
            System.out.println("双向链表为空");
            return;
        }

        HeroNode2 temp = head.next;
        while (temp != null && temp.no != no) {
            temp = temp.next;
        }
        if (temp != null) {
            // 自身删除， 前节点指向后节点，后节点指向前节点。
            temp.pre.next = temp.next;
            if (temp.next != null) {
                temp.next.pre = temp.pre;
            }

        } else {
            System.out.println("找不到删除节点");
        }

    }
}

总结

链表总结回顾

1. 线性表是0个或多个具有相同类型的数据元素的有限序列
2. 线性表按存储结构分为顺序存储结构和链式存储结构
   • 顺序存储 -- 用数组实现，称为顺序表，有大小限制，增删不方便
   • 链式存储 -- 用结点实现，分为多种链表

数据结构-链表

标签：尾插法   拼接   特殊   else   假设   序号   双向   逆序   链式存储结构   

原文地址：https://www.cnblogs.com/1101-/p/13227780.html