数据结构之单链表及单链表反转过程

1. 【栗子】：

public class Note {
    private int id;
    private Object date;
    public Note next;

    public Note(int no, Object date) {
        id = no;
        this.date = date;
    }

    @Override
    public String toString() {
        return "Note{" +
                "id=" + id +
                ", date=" + date +
                '}';
    }
}

public class NoteList {

    private Note head = new Note(0, "");

    public Note getHead() {
        return head;
    }

    //添加节点
    public void add(Note note) {
        Note temp = head;
        while (true) {
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        temp.next = note;
    }

    //显示链表[遍历]
    public void list() {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        Note temp = head.next;
        while (true) {
            if (temp == null) {
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }

    //将单链表反转
    public static void reversetList(Note head) {
        if (head.next == null || head.next.next == null) {
            return;
        }

        Note cur = head.next;
        Note next = null;// 指向当前节点[cur]的下一个节点
        Note reverseHead = new Note(0, "");
        while (cur != null) {
            next = cur.next;              //先暂时保存当前节点的下一个节点，因为后面需要使用
            cur.next = reverseHead.next;  //将cur的下一个节点指向新的链表的最前端
            reverseHead.next = cur;       //将cur 连接到新的链表上
            cur = next;                   //让cur后移
        }
        //将head.next 指向 reverseHead.next , 实现单链表的反转
        head.next = reverseHead.next;
    }


    public static void main(String[] args) {
        NoteList noteList = new NoteList();
        noteList.add(new Note(1, "note1"));
        noteList.add(new Note(2, "note2"));
        noteList.add(new Note(3, "note3"));
        noteList.add(new Note(4, "note4"));
        System.out.println("源数据");
        noteList.list();
        System.out.println("反转后：");
        reversetList(noteList.getHead());
        noteList.list();
    }
}

【输出结果】：

源数据
Note{id=1, date=note1}
Note{id=2, date=note2}
Note{id=3, date=note3}
Note{id=4, date=note4}
反转后：
Note{id=4, date=note4}
Note{id=3, date=note3}
Note{id=2, date=note2}
Note{id=1, date=note1}

2. 【过程详解】：

 【要点】：

从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead 的最前端.
取出，就是断开与下一节点的连接：

  原始数据：

 【第一次循环】：

Note cur = head.next;  //即cur指向note1
next = cur.next;    //即next指向note2，将note2的数据临时保存在next里
·
cur.next = reverseHead.next; //reverseHead.next为null，cur.next即note1.next,所以此语句断开原本note1.next指向的note2，改为null
reverseHead.next = cur;   //cur指向了note1，此语句则是reverseHead.next 的下一个节点为note1，也就是把note1插到reverseHead后面
cur = next;//让cur后移，即cur指向note2

 【第二轮循环】：

Note cur = head.next;  //即cur指向了note2
next = cur.next;    //即next指向note3，将note3的数据临时保存在next里
·
cur.next = reverseHead.next; //reverseHead.next为note1，cur.next即note2.next,所以此语句断开原本note2.next指向的note3，改为指向note1
reverseHead.next = cur;   //cur指向了note2，此语句则是reverseHead.next 的下一个节点为note2，也就是把note2插到reverseHead后面
cur = next;  //让cur后移，即cur指向note3

以此类推即可，以为上个人理解，欢迎讨论