程序员代码面试指南 —— 链表问题（四）

题目：将单链表的每K个节点之间逆序
描述：给定一个单链表的头结点head，实现一个调整单链表的函数，使得每K个节点之间逆序，如果最后不够K个节点一组，则不调整最后几个节点
例如：
链表 1—>2—>3—>4—>5—>6—>7—>8—>null k = 3
调整后：3—>2—>1—>6—>5—>4—>7—>8—>null
想法：逆序可以思考栈stack是否可以解决这个问题，同时循环和递归也可以实现单链表的逆序操作
代码：

public class Test {
  public static void main(String[] args) {
    // init()
    Node head = new Node(1);
    Node node1 = new Node(2);
    Node node2 = new Node(3);
    Node node3 = new Node(4);
    Node node4 = new Node(5);
    Node node5 = new Node(6);
    Node node6 = new Node(7);
    Node node7 = new Node(8);
    head.next = node1;
    node1.next = node2;
    node2.next = node3;
    node3.next = node4;
    node4.next = node5;
    node5.next = node6;
    node6.next = node7;
 
    int k = 3;
    Node res = reverseKNodes(head, k);
 
    while (res != null) {
      System.out.print(res.value + " ");
      res = res.next;
    }
  }
 
  private static Node reverseKNodes(Node head, int k) {
    if (k < 2) {
      return head;
    }
    Node newHead = head;
    Node cur = head;
    Node next = null;
Stack<Node> stack = new Stack<>();
    Node pre = null;
    while (cur != null) {
 
      stack.push(cur);
      next = cur.next;
      if (stack.size() == k) {
        pre = function(pre, next, stack);
        newHead = newHead == head ? cur : newHead;
      }
      cur = next;
    }
    return newHead;
  }
 
  private static Node function(Node left, Node right, Stack<Node> stack) {
    Node cur = stack.pop();
    if (left != null) {
      left.next = cur;
    }
    Node next = null;
    while (!stack.isEmpty()) {
      next = stack.pop();
      cur.next = next;
      cur = next;
    }
    cur.next = right;
    return cur;
  }
}

题目：给定一个无序单链表的头节点head，删除其中值重复出现的节点
描述：例如 1—>2—>3—>3—>4—>4—>2—>1—>1—>null
删除其中的重复节点之后为1—>2—>3—>4—>null
思路：循环遍历删除，或者散列表删除，这里使用循环遍历删除，类似于选择排序

  private static Node function(Node head) {
    Node cur = head;
    Node next = null;
    Node pre = null;
    while (cur != null){
      next = cur.next;
      pre = cur;
      while (next != null){
        if(next.value == cur.value){
          pre.next = next.next;
}else{
 pre = pre.next;
}
next = pre.next;
  }
  cur = cur.next;
}
return head;
  }
}