java单链表的反转(带头结点)

java单链表的反转操作

1.定义节点类

//定义节点类
class Node{
    public int data;
    public Node next;

    public Node(int data){
        this.data = data;
    }
    @Override
    public String toString() {
        return "Node{" +
                "data=" + data + "}";
    }
}

2.定义链表类
把下面的方法放到这个里面

class Linked{

    //定义头，不存数据
    private Node head = new Node(0);
    //返回头
    public Node getHead(){
        return head;
    }
//添加
//显示
//反转
  ｝

3.添加节点的方法(考虑顺序)

//添加考虑顺序
    public void addByOrder(Node node){
        Node temp = head;
        boolean flag = false; //是否要加入的已经存在
        while (true){  //找尾
            if (temp.next==null){
                break;
            }
            if (temp.next.data > node.data){
                break;
            }
            else if(temp.next.data==node.data){
                flag = true;
                break;
            }
            //前三个不成立
            temp = temp.next; //后移继续找
        }
        if (flag){
            System.out.println("已经存在！");
        }else{
            //插入 1 2 3  5 插入4 temp=3 node=4  3.next=5赋值给4.next也就=5 之后证明4.next=5
            node.next =  temp.next; //4 5 相连  就是[3,next] 里面这个next就是[5,next]  赋值之后[4,next] = [4,[5,next]]
            temp.next = node; //　3,4相连  [3,next]=[3,[4,[5,next]]]
        }
    }

4.显示单链表方法

//显示链表
    public void show(){
        //判断空
        if (head.next == null){
            System.out.println("空！！！！");
            return;
        }
        //头部不能动　辅助节点区移动
        Node temp = head.next;
        while (true){
            //1,2,3,4 head是0
            if (temp == null){  //主要用来结束这个循环的，要不是个死循环
                break;
            }
            System.out.println(temp.toString());
            temp = temp.next;
        }
    }

5.反转
建议先把注释删掉再看，为了理解注释打太多了

 /***
     * 单链表的反转操作
     * @param head
     */
    public static void reverse(Node head){

        //
        if (head.next==null || head.next.next==null){
            return;
        }
        //定义辅助
        Node cur = head.next;
        Node next = null;
        Node newHead = new Node(0);

        //遍历需要反转的链表 [1,[2,[3,[4,[null]]]]]
        //resver [0,next]
        while (cur != null){    //cur=[1,[next]]  ;  cur=[2,[next]]
            //保存节点移动使用,为什么要保存?　接下来这一步给它next置空了
            next = cur.next;// cur.next=[2,[next]]  ;   cur.next=[3,[next]]
            //这步你可以想象成打造好一个数据准备给newHead.next拼
            //第一次cur=1后面next是2,3,4都不需要置空
            //第二次cur=2后面next是3,4你必须给他赋值成1,才能实现反转 此时newHead.next就是1
            //第三次cur=3后面next是4你必须给他赋值成2,1,才能实现反转 此时newHead.next就是2,1
            //类推...
            cur.next = newHead.next;//newHead.next=null , cur.next=[2,[next]] = [2,[null]] ;
            //上一步把cur的next值弄好了,这一步就是与新节点的头相连
            newHead.next = cur; // [0,null] = [0,[1,null]] ;  newHead.next=[0,[1,null]]= [0,[2,[1,[null]]]]
            cur = next; //移动 cur=[2,[text]] ;
            //最后 newHead=[0,[4,[3,[2,[1[null]]]]]
        }

        // resver0,4,3,2,1
        head.next = newHead.next;


    }

测试代码：

public class SingleLinkedList {

    public static void main(String[] args) {

        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        
        Linked linked = new Linked();

        linked.addByOrder(node1);
        linked.addByOrder(node4);
        linked.addByOrder(node3);
        linked.addByOrder(node2);
        System.out.println("头结点是"+linked.getHead());
      // System.out.println("有效节点的个数"+Linked.getLength(linked.getHead()));
       // System.out.println("倒数第二个是"+Linked.findLastIndexNode(linked.getHead(),2));
        linked.show();
        System.out.println("---------");
       // linked.delete(1);
        linked.show();
        System.out.println("--------");
        Linked.reverse(linked.getHead());
        System.out.println("反转之后头结点是"+linked.getHead());
        linked.show();
    }
}

结果显示：