链表创建，单链表反转，逆序打印等等

• 链表是以节点的方式来存储
• 每个节点都包含一个data域和next域，data域用来存放数据，next域用来指向下一个节点
• 链表的各个节点不一定是连续存储的

先来看普通链表的代码是如何创建的

首先需要一个节点类，命名为Node，这里的属性我设置的为public，如果有序要也可以设置为private，并提供响应的getter和setter方法即可：

class Node{//节点类
    public int node;//存放节点的序号，你也可以在后面写多个变量
    public Node next;//指向下一个节点
    
    public Node(int node) {//有参的构造器
        this.node = node;
    }
    
    public Node() {//空参构造器
    }

    @Override
    public String toString() {
        return "Node{" +
                "node=" + node +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

有了节点类，我们还需要一个链表类LinkedList，用来写增删改查等等一些方法:

class SingleLinkedList{//创建一个链表
    //初始化头节点
    private Node head = new Node();
	//由于是私有化头节点，所以提供响应的get方法即可
    public Node getHead() {
        return head;
    }

    //不考虑编号顺序时添加数据
    public void add(Node node){
        Node temp = head;//因为头节点不能动，所以使用临时变量来进行指针的挪动
        //遍历链表
        while (true) {
            if (temp.next == null) {//此时说明遍历到了链表的最后
                break;
            }
            temp = temp.next;//每循环一次让指针向后挪动一位
        }
        temp.next = node;//让当前指针指向添加的节点
    }

    //考虑编号顺序时添加数据
    public void addOrderBy(Node heroNode){
        Node temp = head;
        boolean flag = false;//标志编号是否存在
        while (true) {
            if (temp.next == null){
                break;
            }
            if (temp.next.node > heroNode.node) {//传入的节点的编号小于它的后一个节点的编号时停止
                break;
            } else if (temp.next.node == heroNode.node) {//说明节点已经存在
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            System.out.println("要插入的编号已经存在~~");
        }else {
            heroNode.next = temp.next;//让要插入节点的nxet域指向之前的temp的next域
            temp.next = heroNode;//再让temp的next域指向传入的节点
        }
    }

    //遍历链表的方法
    public void list(){
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        Node temp = head.next;
        while (true){
            if (temp == null){
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }

    //删除一个节点的方法
    public void delete(Node node){
        Node temp = head;
        boolean flag = false;
        while (true){
            if (temp.next == null) {
                break;
            }
            if (temp.next.node == node.node){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.next = temp.next.next;
        }else {
            System.out.println("要删除的节点不存在");
        }
    }

    //修改节点的方法
    public void update(Node newNode){
        Node temp = head.next;
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        boolean flag = false;
        while (true) {
            if (temp == null){
                break;
            }
            if (temp.node == newNode.node){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.name = newNode.name;
        }else {
            System.out.println("没有找到");
        }
    }
}

//测试类我就不再写了

• 有序的插入图解：
  
• 删除的图解：
  
  值得一提的是上面代码中的修改方法是根据序号来修改其它属性的值，由于没有设置其它属性，因此也就不做说明了

关于单链表的面试题

1. 求单链表有效节点的个数
2. 查询单链表中倒数第k个节点
3. 单链表的反转
4. 逆序打印链表中的节点

	//直接写方法了
	/**
     * 获取链表中有效节点的个数
     * @param head  传入一个头节点
     */
public static int getLength(Node head){
	Node temp = head.next;//使用临时变量标记头节点
	if(head.next == null){
		return 0;//说明链表为空
	}
	int length = 0;//用来统计有效节点的个数
	while (true){
        if (temp != null) {
            length++;
            temp = temp.next;
        }else
            break;
	}
    return length;
}

//获取单链表中倒数第k个节点
public static Node getNode(Node head,int k){
	Node temp = head.next;
	if(head.next == null){
		return null;//说明链表为空
	}
	//这里比较巧妙的方法是直接调用上面获取有效节点个数的方法
	int size = getLength(head);
	if(k <= 0 || k > size){
		return null;
	}
	for(int i = 0; i < (size - index); i++){
		if (temp.next != null) {
			temp = temp.next;
		}
	}
	return temp;
}

//单链表的反转
public void reverseLinkedList(Node head){
    //如果链表为空或者只有一个节点则无需反转
    if (head.next == null || head.next.next == null) {
        return;
    }
    Node temp = head.next;
    Node next = null;
    Node reverseHead = new Node();//创建一个新的链表
    while (temp != null) {
        next = temp.next;   //先暂时保存当前节点的下一个节点，因为后面需要使用
        temp.next = reverseHead.next;   //
        reverseHead.next = temp;    //反转后的链表头节点指向当前的temp
        temp = next;    //让temp后移
    }

    head.next = reverseHead.next;
}

上个图解释一下单链表的反转：

//逆序打印链表中的节点
//通过栈的先进后出的性质把链表中的数据顺序压入，再顺序弹出即可
public static void reverseOrder(Node head){
    if (head.next == null){
        return;
    }
    //创建一个栈对象
    Stack<Node> nodes = new Stack<>();
    Node temp = head.next;
    while (temp != null){
        nodes.push(temp);
        temp = temp.next;
    }
    //进行出栈操作
    while (nodes.size() > 0) {
        System.out.println(nodes.pop());
    }
}

以上就是我个人在学习单链表之后的一些练习和理解
如果对大家有帮助，请点赞支持
请勿转载