循环链表---对象赋值的相关问题

• 问题引入

1. 单向循环链表节点的定义：

    public class CirNode<T>
    {
        public T Item { get; set; }
        public CirNode<T> Next { get; set; }

        public CirNode()
        {
        }

        public CirNode(T item)
        {
            this.Item = item;
        }
    }

　　2.单向循环链表的模拟实现：

    /// <summary>
    /// 单向循环链表的模拟实现
    /// </summary>
    public class MyCircularLinkedList<T>
    {
        private int count; // 字段：记录数据元素个数
        private CirNode<T> tail; // 字段：记录尾节点的指针
        private CirNode<T> currentPrev; // 字段：使用前驱节点标识当前节点

        // 属性：指示链表中元素的个数
        public int Count
        {
            get
            {
                return this.count;
            }
        }

        // 属性：指示当前节点中的元素值
        public T CurrentItem
        {
            get
            {
                return this.currentPrev.Next.Item;
            }
        }

        public MyCircularLinkedList()
        {
            this.count = 0;
            this.tail = null;
        }

        public bool IsEmpty()
        {
            return this.tail == null;
        }

        // Method01:根据索引获取节点
        private CirNode<T> GetNodeByIndex(int index)
        {
            if (index < 0 || index >= this.count)
            {
                throw new ArgumentOutOfRangeException("index", "索引超出范围");
            }

            CirNode<T> tempNode = this.tail.Next;
            for (int i = 0; i < index; i++)
            {
                tempNode = tempNode.Next;
            }

            return tempNode;
        }

        // Method02:在尾节点后插入新节点
        public void Add(T value)
        {
            CirNode<T> newNode = new CirNode<T>(value);
            if (this.tail == null)
            {
                // 如果链表当前为空则新元素既是尾头结点也是头结点
                this.tail = newNode;
                this.tail.Next = newNode;
                this.currentPrev = newNode;
            }
            else
            {
                // 插入到链表末尾处
                newNode.Next = this.tail.Next;
                this.tail.Next = newNode;
                // 改变当前节点
                if (this.currentPrev == this.tail)
                {
                    this.currentPrev = newNode;
                }
                // 重新指向新的尾节点
                this.tail = newNode;
            }
            Console.WriteLine(this.currentPrev.Next.Item);
            this.count++;
        }

        // Method03:移除当前所在节点
        public void Remove()
        {
            if (this.tail == null)
            {
                throw new NullReferenceException("链表中没有任何元素");
            }
            else if (this.count == 1)
            {
                // 只有一个元素时将两个指针置为空
                this.tail = null;
                this.currentPrev = null;
            }
            else
            {
                if (this.currentPrev.Next == this.tail)
                {
                    // 当删除的是尾指针所指向的节点时
                    this.tail = this.currentPrev;
                }
                // 移除当前节点
                this.currentPrev.Next = this.currentPrev.Next.Next;
            }

            this.count--;
        }

        // Method04:获取所有节点信息
        public string GetAllNodes()
        {
            if (this.count == 0)
            {
                throw new NullReferenceException("链表中没有任何元素");
            }
            else
            {
                CirNode<T> tempNode = this.tail.Next;
                string result = string.Empty;
                for (int i = 0; i < this.count; i++)
                {
                    result += tempNode.Item + " ";
                    tempNode = tempNode.Next;
                }

                return result;
            }
        }
    }

其中循环链表新节点的插入实现方法中，用了对象赋值给另一个对象：

        public void Add(T value)
        {
            CirNode<T> newNode = new CirNode<T>(value);
            if (this.tail == null)
            {
                // 如果链表当前为空则新元素既是尾头结点也是头结点
                this.tail = newNode;//@1
                this.tail.Next = newNode;//@2
                this.currentPrev = newNode;//@3
            }
            else
            {
                // 插入到链表末尾处
                newNode.Next = this.tail.Next;
                this.tail.Next = newNode;
                // 改变当前节点
                if (this.currentPrev == this.tail)
                {
                    this.currentPrev = newNode;
                }
                // 重新指向新的尾节点
                this.tail = newNode;
            }
            Console.WriteLine(this.currentPrev.Next.Item);
            this.count++;
        }

• 问题原因

其中@1处，把新new的一个对象newNode赋值给this.tail，此时这两个对象引用的是同一个内存地址空间，newNode.Next=null,this.tail.Next也是为Null,而到@2这一步时，给this.tail.Next赋值为newNode时，同时也会对newNode进行操作既给newNode.Next赋值，因为这两个对象引用的是同一个地址空间。

• 问题引申
• 1.浅复制和深复制：

浅复制：

 public class Test
 {
      public string A { get; set; }
      public int B { get; set; }
      public override string ToString()
      {
          return $"A:{A},B:{B}";
      }
 }
    static void Main(string[] args)
      {
             var list = new List<Test>()
             {
                 new Test(){A="A1",B=1 },
                 new Test(){ A="A2",B=2}
             };
             var list_Copy = list.ToList();
             list_Copy[0].A = "这是修改后的值";
             foreach (var i in list)
             {
                 Console.WriteLine(i);
             }
             Console.Read();
      }

执行结果：

由上图可以看出，这里与循环链表里面的插入方法中的@1是一样的，修改list_Copy的元素的属性值，list中的元素的属性也跟着变了。

 

深复制：

 public class Test:ICloneable
    {
        public string A { get; set; }
        public int B { get; set; }

        public object Clone()
        {
            return this.MemberwiseClone();
        }

        public override string ToString()
        {
            return $"A:{A},B:{B}";
        }
    }
    static void Main(string[] args)
        {
            var list = new List<Test>()
            {
                new Test(){A="A1",B=1 },
                new Test(){ A="A2",B=2}
            };
            var list_Copy = new List<Test>();
            list.ForEach(x => list_Copy.Add(x.Clone() as Test));
            list_Copy[0].A = "这是修改后的值";
            foreach (var i in list)
            {
                Console.WriteLine(i);
            }
            Console.Read();
        }

运行结果：

可以看出，修改list_Copy的任何元素任何属性，都不会影响到list，但是list与list_Copy中的元素值是相同的，这就是深复制。

深复制还可以借用json：

public static void Copy<T>(T source, ref T destination) where T : class
  {
        string jsonStr = Newtonsoft.Json.JsonConvert.SerializeObject(source);
        destination = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(jsonStr);
  }

• 2.LeetCode上相关的题目：

问题描述：

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

解决代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public int val;
 *     public ListNode next;
 *     public ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode AddTwoNumbers(ListNode l1, ListNode l2) {
            ListNode result = new ListNode(0);
            ListNode cursor = result;
            int carrybit = 0;
            while (l1 != null||l2!=null|| carrybit!=0)
            {
                int sum = (l1 == null ? 0 : l1.val) + (l2 == null ? 0 : l2.val) + carrybit;
                carrybit = sum / 10;
                ListNode sumNode = new ListNode(sum % 10);
                cursor.next = sumNode;
                cursor = sumNode;
                l1 = (l1 == null ? null : l1.next);
                l2 = l2 == null ? null : l2.next;
            }
            return result.next;
    }
}

首先是定义了两个ListNode对象，由于直接把result赋值给cursor，所以两者引用的是同一个地址。在While循环中定义的sumNode的内存空间的地址每次都不一样，当把cursor.next赋值为sumNode时，同时也会对result.next进行赋值操作。最重要的一步是把sumNode赋值给了cursor，这时cursor不再指向result的地址，而是指向这一次的sumNode的地址，此时也就是变为result.next=cursor。

所以最后返回result.next就能把初始化的值0从链表中去掉。

 

代码对应的流程：

 

参考文章链接：

1. https://www.cnblogs.com/edisonchou/p/4614934.html
2. https://blog.csdn.net/lishuangquan1987/article/details/86085971