单向链表的定义以及基本操作

简介

 单向链表的特点
 	1. 链表是一种在物理存储上非连续，非顺序的存储结构.
 	2. 连接方向是单向的.
 	3. 访问链表要从头部顺序读取.
 	4. 是由一个个节点组装而成的.
 	5. 每个节点都有类似指针的变量指向链表下一个节点.

定义链表

Java中需要我们自己定义一个链表的类来生成对象，这个类至少需要定义两个属性：
 1. 一个存储数据的数据域。
 2. 一个存储下一个节点地址的指针域。

class ListNode {
    int id;
    int val;
    ListNode next; //指向下一个节点

    public ListNode(int id, int val) {
        this.id = id;
        this.val = val;
    }

    @Override
    public String toString() {
        return "ListNode{" +
                "id=" + id +
                "val=" + val +
                '}';
    }

}

链表的基本操作方法(基于带有头结点的链表)

 1. 获取头结点
 2. 添加节点
 3. 删除节点
 4. 修改节点
 5. 查看链表
 6. 对插入的节点进行排序

class OperateLinkedList {
    private ListNode headNode = new ListNode(0, 0);//设置头结点，方便对链表的头部进行操作

    //返回头结点
    public ListNode getHeadNode() {
        return headNode;
    }

    //添加节点
    public void addListNode(ListNode listNode) {
        ListNode temp = headNode;
        while (true) {
            if (temp.next != null) {
                temp = temp.next;
            } else {
                temp.next = listNode;
                break;
            }
        }
    }

    //查看链表
    public void showLinkedList(ListNode headNode) {
        //判断列表是否为空
        if (headNode.next == null) {
            System.out.println("此链表为空链表");
        }
        ListNode temp = headNode.next;
        while (true) {
            if (temp == null) {
                break;
            } else {
                System.out.println(temp);
                temp = temp.next;
            }
        }
    }

    //修改链表的节点数据
    public void updateListNode(ListNode listNode) {
        //判断列表是否为空
        if (headNode.next == null) {
            System.out.println("链表为空");
        }
        ListNode temp = headNode.next;
        boolean flag = false;
        while (true) {

            if (temp.id == listNode.id) {
                flag = true;
                break;
            } else {
                if (temp.next == null) {
                    break;
                }
                temp = temp.next;
            }

        }
        if (flag) {
            temp.val = listNode.val;
        } else {
            System.out.println("没有找到此节点");
        }
    }

    //删除节点
    public void delListNode(int id) {
        ListNode temp = headNode.next;
        boolean flag = false;
        //找目标节点的前一个节点
        while (true) {
            //遍历到最后，退出
            if (temp.next == null) {
                break;
            }
            //找到节点
            if (temp.next.id == id) {
                flag = true;
                break;
            }

            temp = temp.next;
        }
        if (flag) {
            temp.next = temp.next.next;
        } else {
            System.out.println("没有找到此节点");
        }
    }

    //按值排序
    public void addReorder(ListNode listNode) {
        ListNode temp = headNode;
        while (true) {
            if (temp.next == null) {
                temp.next = listNode;
                break;
            } else {
                if (temp.next.val <=listNode.val) {
                    temp = temp.next;
                }else {
                    listNode.next=temp.next;
                    temp.next=listNode;
                    break;
                }
            }
        }
    }
}

操作链表

public class SinglyLinkedList {
    public static void main(String[] args) {
        OperateLinkedList operateLinkedList = new OperateLinkedList();
        //创建节点
        ListNode listNode1 = new ListNode(1, 1);
        ListNode listNode2 = new ListNode(2, 2);
        ListNode listNode3 = new ListNode(3, 3);
        ListNode listNode4 = new ListNode(4, 4);
        ListNode listNode5 = new ListNode(5, 5);
        ListNode listNode6 = new ListNode(6, 4);
        ListNode listNode7 = new ListNode(7, 3);
        ListNode listNode8 = new ListNode(8, 2);
        //添加节点
//        operateLinkedList.addListNode(listNode1);
//        operateLinkedList.addListNode(listNode2);
//        operateLinkedList.addListNode(listNode3);
//        operateLinkedList.addListNode(listNode4);
//        operateLinkedList.addListNode(listNode5);
        operateLinkedList.addReorder(listNode5);
//        operateLinkedList.showLinkedList(operateLinkedList.getHeadNode());
        operateLinkedList.addReorder(listNode4);
//        operateLinkedList.showLinkedList(operateLinkedList.getHeadNode());
        operateLinkedList.addReorder(listNode3);
//        operateLinkedList.showLinkedList(operateLinkedList.getHeadNode());
        operateLinkedList.addReorder(listNode2);
//        operateLinkedList.showLinkedList(operateLinkedList.getHeadNode());
//        operateLinkedList.addReorder(listNode4);
//        operateLinkedList.showLinkedList(operateLinkedList.getHeadNode());
//        operateLinkedList.addReorder(listNode4);
        operateLinkedList.addReorder(listNode1);
        operateLinkedList.addReorder(listNode6);
        operateLinkedList.addReorder(listNode7);
        operateLinkedList.addReorder(listNode8);
//        operateLinkedList.addReorder(listNode5);
        //显示节点
        operateLinkedList.showLinkedList(operateLinkedList.getHeadNode());
        //修改节点
//        System.out.println("-------------------------------------");
//        operateLinkedList.updateListNode(new ListNode(5, 8));
//        operateLinkedList.showLinkedList(operateLinkedList.getHeadNode());

    }

}