单链表的反转与逆序打印

单链表的反转与逆序打印

1. 单链表反转的思路
1.创建一个新的头结点
2.遍历原来的单链表，依次把各个数据节点插入到新头结点后面
3.把新头结点的指向换为原来头结点的指向

2.单链表逆序打印的思路
1.利用栈先进后出的特点，把单链表各个数据节点依次压栈，压栈完成之后在进行弹栈

3. 代码如下

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedListNode2 linkedListNode2 = new LinkedListNode2();
        LinkedNode node1 = new LinkedNode(1,"张一");
        LinkedNode node2 = new LinkedNode(2,"张二");
        LinkedNode node3 = new LinkedNode(3,"张三");
        LinkedNode node4 = new LinkedNode(4,"张四");
        LinkedNode node5 = new LinkedNode(5,"张五");
        linkedListNode2.addTail(node1);
        linkedListNode2.addTail(node2);
        linkedListNode2.addTail(node3);
        linkedListNode2.addTail(node4);
        linkedListNode2.addTail(node5);
        linkedListNode2.show();
        System.out.println("逆序输出！");
        linkedListNode2.reversePrint();
        System.out.println("反转单链表！");
        linkedListNode2.reserve(linkedListNode2.getHead());
        linkedListNode2.show();
    }
}
class LinkedListNode2{
    //创建头节点
    private LinkedNode head = new LinkedNode(0,"");

    public LinkedListNode2(){

    }

    public LinkedNode getHead() {
        return head;
    }

    //尾插法
    public void addTail(LinkedNode node){
        LinkedNode temp;//辅助指针，移动到末尾之后开始插入操作
        for (temp = this.head ; temp.next != null ; temp = temp.next) {

        }
        //开始插入操作
        temp.next = node;
    }

    //遍历
    public void show(){
        if (this.head.next == null){
            System.out.println("当前单链表为空！");
        }else{
            for (LinkedNode temp = this.head.next ; temp != null ; temp = temp.next) {
                System.out.println(temp.toString());
            }
        }
    }

    //单链表反转，方法一
    //1.创建一个新的头结点
    //2.遍历原链表，依次把各个数据节点插入到新链表的前面
    //3.把新头指针的指向换为原来头指针的指向
    public void reserve(LinkedNode headNode){
        //首先判断当前头结点是否为空，或者只有一个数据节点
        if (headNode.next == null && headNode.next.next == null){
            System.out.println("当前单链表为空，没有必要反转！");
        }else{
            //创建一个新的头结点
            LinkedNode newHead = new LinkedNode(0,"");
            //辅助指针
            LinkedNode temp = headNode.next;
            //辅助指针，指向上一个辅助指针的下一个节点
            LinkedNode next;
            //开始遍历原链表
            while (temp != null){
                next = temp.next;//指向上一个辅助指针的下一个节点
                temp.next = newHead.next;//将temp的下一个节点指向新的链表的最前端
                newHead.next = temp;//插入到新头节点的后面
                temp = next;
            }

            //最后把新头指针的指向为原来头指针的指向
            headNode.next = newHead.next;
        }
    }
    //从尾到头打印单链表
    public void reversePrint(){
        if (this.head.next == null && this.head.next.next == null){
            System.out.println("当前单链表为空，没有必要逆序打印！");
        }else{
            //创建一个栈用来存储数据
            Stack<LinkedNode> stack = new Stack<>();
            for (LinkedNode temp = this.head.next; temp != null; temp = temp.next) {
                //入栈
                stack.push(temp);
            }
            //出栈，达到一个逆序的效果
            while (stack.size() > 0){
                System.out.println(stack.pop().toString());
            }
        }
    }
}
class LinkedNode{
    public int index;
    public String name;
    public LinkedNode next;

    public LinkedNode(int index,String name){
        this.index = index;
        this.name = name;
    }

    @Override
    public String toString() {
        return "LinkedNode{" +
                "index=" + index +
                ", name='" + name + '\'' +
                '}';
    }
}

标签：单链,temp,linkedListNode2,打印,next,LinkedNode,public,逆序
来源： https://blog.csdn.net/qq_46589658/article/details/120656135