单双链表及其反转——堆栈诠释

按值传递

• int、long、byte、short、char、float、double、boolean和String 都是按值传递

• 概念：在方法被调用时，实参通过形参把它的内容副本传入方法内部，此时形参接收到的内容是实参值的一个拷贝，因此在方法内对形参的任何操作，都仅仅是对这个副本的操作，不影响原始值的内容

• 分析：向函数传参时，只是在栈中生成变量a的一个副本a1，在函数内被修改的a其实是a1，所以函数内修改参数的值并不会影响实参的值，这就是值传递

  int a = 10;
  f(a);
  system.out.println(a);
  
  public static void f(int a) {
      a = 0;
  }
  
  // 结果还是打印10
  

按引用传递

• 其他类型和数值都是按引用传递

• 概念：”引用”也就是指向真实内容的地址值，在方法调用时，实参的地址通过方法调用被传递给相应的形参，在方法体内，形参和实参指向通愉快内存地址，对形参的操作会影响的真实内容

• 分析：

  • 创建Number对象存储在堆中，并将其引用地址赋值给变量b
  • 调用g1()和g2()方法时，栈空间中会拷贝对象引用地址为b1和b2并作为参数传递，因此b、b1和b2都指向堆中同一个Number对象
  • 在g1()方法中，将参数b1修改为null，这只是改变了b1的指向，不影响主函数中变量b的指向，主函数的b仍然指向原来的Number对象。
  • 在g2()方法中，通过参数b2修改b2.val的值为6，这相当于通过b2的引用地址找到并修改了堆中Number对象的val值，因此主函数中变量b所指向的Number对象的val值也会被修改
  • 总结：指向的是同一个内存区域，但是不同的两个引用

  public static void main(String[] args){
      Number b = new Number(5);
      g1(b);
      System.out.println(b.val);
      g2(b);
      System.out.println(b.val);
  }
  // 结果：
  // 5
  // 6
  
  public static class Number{
      public int val;
      public Number(int v){
          val = v;
      }
  }
  
  public static void g1(Number b){
      b = null;
  }
  
  public static void g3(Number b){
      b.val = 6;
  }
  
  public static void g3(int[] c){
      c = null;
  }
  

单链表的定义

• 什么是单链表，单链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null
• 单链表不要求逻辑上相邻的两个元素在物理位置上也相邻，因此不需要连续的存储空间
• 单链表的入口节点称为链表的头结点也就是head

public class ListNode {
    // 结点的值
    public int val;
    // 下一个节点
    public ListNode next;
    
    // 节点的构造函数(有两个参数)
    public ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}

双链表的定义

• 什么是双链表，双链表是一种通过指针串联在一起的线性结构，每一个节点由三部分组成，每个节点包含数据域、指向下一个节点的指针（next）和指向前一个节点的指针（prev）
• 双链表 既可以向前查询也可以向后查询
• 双链表的入口节点称为链表的头结点也就是head

public class DoubleListNode {
    // 结点的值
    public int val;
    // 下一个节点
    public DoubleListNode next;
    // 上一个节点
    public DoubleListNode prev;
    
    // 节点的构造函数(有两个参数)
    public ListNode(int val, DoubleListNode next) {
        this.val = val;
        this.prev = prev;
        this.next = next;
    }
}

反转单链表

public static 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;
}

反转双链表

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