java 单链表实现翻转－－腾讯面试题

方法一：申请辅助头结点，遍历原链表，将每一个节点插入到新链表上的头结点之后，最后将原链表的头指向新链表的第一个节点

  public static void reverseNew(HeroNode head) {
        HeroNode p = head.next;

        HeroNode n = new HeroNode(0, "");

        while (p != null) {
         // 在原链表中删除该节点
            head.next = p.next; 
            p.next = null;
         // 将删除的节点插入到新链表头节点之后 
            p.next = n.next;
            n.next = p;
　　　　　// 指向原链表的第一个节点
            p = head.next;
        }
　　　　　// 将原链表的头节点指向新链表的第一个节点
        head.next = n.next;
        n.next = null;

    }

方法二：在原链表上操作

public static void reverse(HeroNode head){
        HeroNode p = head.next.next;
        HeroNode n = p.next;
       int count = 0;
 // 如果链表只有一个节点就不用反转
        if(p==null) return;

        while(p != null){
        　// 将两个节点之间的指向反转
            p.next = head.next;
         //  如果遍历的第一个节点的next不设置空的话，打印时前两个节点就会死循环
            if(count == 0) {
                p.next.next = null;
                count = 1;
            }
            // 头节点移动
            head.next = p;
            p = n;
            if(n == null) break;
            n = p.next;
        }


    }

其他（创增删改…）

1. 获取单链表的节点个数

public static int getLength(HeroNode head) {
        HeroNode p = head.next;
        int count = 0;
        while (p != null) {
            count++;
            p = p.next;
        }

        return count;
    }

2. 获取单链表中的倒数第k个节点

 public static HeroNode getNodeK(HeroNode head, int k) {
        if (head.next == null) {
            System.out.println("空链表");
            return null;
        }
        int num = getLength(head); //有效节点个数
        HeroNode p = head.next;

        for (int i = 0; i < num - k; i++)
            p = p.next;

        return p;
    }

3. 创建节点

class HeroNode {
    int no;
    String name;
    public HeroNode next;

    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;

    }


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

4. 创建单链表及链表上的一些操作

class LinkedList {
    private HeroNode head; //头结点
    public HeroNode getHead() {
        return head;
    }
    public LinkedList() {
        head = new HeroNode(0, "");
    }
//    不按编号创建
    public void add(HeroNode node) {
//        找到尾节点
//        创建一个辅助节点
        HeroNode p = head;
        while (p.next != null) {
            p = p.next;
        }
//        插入
        p.next = node;
    }


    //    按编号顺序插入
    public void addByOrder(HeroNode node) {
        HeroNode p = head;
        boolean flag = false;

        while (true) {
            if (p.next == null) {
                break;
            } else if (p.next.no > node.no) {
                flag = true;
                break;
            }
            p = p.next;
        }
        if (flag) {
            node.next = p.next;
            p.next = node;
        } else {
            p.next = node;
        }
    }


    //    根据编号修改名字
    public void modify(HeroNode node) {
        HeroNode p = head.next;

        while (p != null) {
            if (p.no == node.no) break;
            p = p.next;
        }

        if (p == null) {
            System.out.println("没有找到该节点");
        } else {
            p.name = node.name;
        }
    }

    //    按编号删除节点
    public void delete(int aim) {
        HeroNode p = head;
        boolean flag = false;
        while (true) {
            if (p.next == null) {
                break;
            } else if (p.next.no == aim) {
                flag = true;
                break;
            }

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

    //    展示链表
    public void show() {
        if (head.next == null)
            return;
//        创建一个辅助节点
        HeroNode p = head.next;

//        遍历
        while (true) {

            System.out.println(p);
            p = p.next;
            if (p == null) break;
        }
    }

}