打败算法第一节之单链表1

引言

算法在大厂面试中占有一定地位，写此专栏的初衷是想跟大家一起学习算法，也是想督促自己每天学习😜
今天准备了几道关于单链表的简单题，我们一起来看一下吧！

简单题

1.反转单链表

• 简单，LCR024、206反转链表
• 题目描述：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
  输入：head = [1,2,3,4,5]
  输出：[5,4,3,2,1]

//单链表数据结构
public class ListNode {
      int val;//当前节点的值
      ListNode next;//指向后继节点的指针
      ListNode() {}
      ListNode(int val) { this.val = val; }
      ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 }
//方法定义
 public ListNode reverseList(ListNode head) {}

• 思路：定义两个节点pre和next，分别为当前节点的前一个节点和当前节点的后一个节点。当 当前节点不为空的时候，连接指针，之后将节点后移。返回pre节点即是新的头节点。

public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode next = null;
        while(head != null){
            next = head.next;
            
            head.next = pre;
            
            pre = head;
            head = next;
        }
        return pre;
    }

2.反转双链表（在leetcode中没找到题）

• 题目描述：给你双链表的头指针 head ，请你反转链表节点，返回 反转后的链表 。

//双链表数据结构
public static class DoubleNode {
		public int value;
		public DoubleNode last;
		public DoubleNode next;
		public DoubleNode(int data) {
			value = data;
		}
	}

• 思路：同单链表，定义两个节点pre和next，分别为当前节点的前一个节点和当前节点的后一个节点。当 当前节点不为空的时候，连接指针（双向链表需要将前驱指针和后继指针都连接），之后将节点后移。返回pre节点即是新的头节点。

public static DoubleNode reverseDoubleList(DoubleNode head) {
		DoubleNode pre = null;
		DoubleNode next = null;
		while (head != null) {
			next = head.next;
			
			head.next = pre;
			head.last = next;
			
			pre = head;
			head = next;
		}
		return pre;
	}

3.删除链表的节点

• LCR136删除链表的节点
• 题目描述：给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。返回删除后的链表的头节点。
  题目保证链表中节点的值互不相同
  输入: head = [4,5,1,9], val = 5
  输出: [4,1,9]
  解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.

//方法定义
public ListNode deleteNode(ListNode head, int val) {}

• 思路：题目保证链表中节点的值互不相同,所以给定的val如果有的话只会有一个，先判断头节点的值是否为val，如果是的话则新链表的头节点就是返回的头节点；如果不是的话定义两个节点，一个是pre节点，初始化为头节点，一个是cur节点，初始化为头节点的下一个节点，循环遍历节点直到找到值为val的节点，然后将pre的next指针指向cur的下一个节点，再返回pre节点。

public ListNode deleteNode(ListNode head, int val) {
        if(head.val == val){
            return head.next;
        }
        ListNode pre = head;
        ListNode cur = head.next;
        while(cur != null && cur.val != val){
            pre = cur;
            cur = cur.next;
        }
        if(cur.val == val){
            pre.next = cur.next;
        }
        return pre;
    }

4.题目3的进阶：节点的值可能会相同（leetcode没找到）

• 题目描述：给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。返回删除后的链表的头节点。并不保证各个节点的值都不相同，即节点的值可能重复。
  输入: head = [4,5,1,5,9], val = 5
  输出: [4,1,9]

//单链表数据结构
public class ListNode {
      int val;//当前节点的值
      ListNode next;//指向后继节点的指针
      ListNode() {}
      ListNode(int val) { this.val = val; }
      ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 }
//方法定义
public ListNode removeValue(ListNode head, int num) {}

• 思路：因为给定要删除的值可能在头节点，所以先找到第一个不需要删除的位置，然后定义两个指针pre和cur，从当前节点一直遍历到链表结尾，遍历过程中判断当前节点是否为要删除的节点，是的话就需要删除节点再连接成链表。

public static Node removeValue(Node head, int num) {
		// head来到第一个不需要删的位置
		while (head != null) {
			if (head.value != num) {
				break;
			}
			head = head.next;
		}
		Node pre = head;
		Node cur = head;
		while (cur != null) {
			if (cur.value == num) {
				pre.next = cur.next;
			} else {
				pre = cur;
			}
			cur = cur.next;
		}
		return head;
	}