链表

我们知道,线性表分为顺序存储和链式存储,顺序存储的缺点是在插入和删除时需要移动大量的元素,为了解决这个问题,就有了链式存储.

一.单链表

---

 

每个结点(Node)包含数据域和一个指针域,指针指向下一个结点.

 

第一个结点前可设置一个结点,称为头结点,不是必须.

头指针和头结点:

 

 

单链表指定位置的读取

---

 思路:因为链表为链式存储不知道具体位置,所以需要从头结点(第一个结点)开始

public class LinkList
    {
        /// <summary>
        /// 获取单链表指定位置的结点
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="head">单链表的第一个结点</param>
        /// <param name="i">位置</param>
        /// <returns></returns>
        public Node<T> GetNode<T>(Node<T> head ,int i)
        {
            int j = 0;

            //循环读取下一个结点
            while (head != null && j < i)
            {
                head = head.next;
                j++;
            }
            if (head == null || j > i)
            {
                return null;
            }

            return head;
        }
    }

    #region 单链表结点
    /// <summary>
    /// 单链表
    /// </summary>
    public class Node<T>
    {
        //数据域
        public T data;

        //节点的指针域
        public Node<T> next;
    }
    #endregion

View Code

 

插入到指定位置

---

思路: 把前项的后继节点改成要插入的项,把插入项的后继节点变成后项节点,如图所示:

 

public void InsertNode<T>(Node<T> head,int i,Node<T> nodeToInsert)
        {
            //要插入节点的前项
            Node<T> before;
            before = GetNode<T>(head, i-1);

            //先判断位置是否存在
            if (before == null)
            {
                return;
            }

            nodeToInsert.next = before.next;
            before.next = nodeToInsert;
        }

View Code

 

删除指定位置的节点

---

 

思路:看图

 

public Node<T> DeleteNode<T>(Node<T> head, int i)
        {
            //要删除节点的前项
            Node<T> before,after, middle;
            before = GetNode<T>(head, i - 1);
            middle = before.next;
            after = middle.next;

            //先判断是否存在
            if (before == null || middle==null)
            {
                return null;
            }

            before.next = after;

            //返回被删除的节点
            return middle;
        }

View Code

 

构建单链表

---

 

1.头插法

 

 public void CreateLinkList(int num)
        {
            Node<int> head= new Node<int>();
            Node<int> node;

            for (int i = 0; i < num; i++)
            {
                node = new Node<int>();
                node.data = i;
                node.next = head.next;
                head.next = node;
            }
        }

View Code

 

2.尾插法

 

 

 

 

 /// <summary>
        /// 构建单链表-尾插法
        /// </summary>
        /// <param name="num"></param>
        public void CreateLinkListTail(int num)
        {
            Node<int> end = new Node<int>();
            Node<int> node;

            for (int i = 0; i < num; i++)
            {
                node = new Node<int>();
                node.data = i;
                end.next = node;
                end = node;
            }
            //链表结束
            end.next = null;
        }

View Code

 

二.循环链表

---

 

将单链表的最后一个节点的指针改为指向头结点,形成一个环,使得从任意节点访问都可以遍历到所有节点.

三.双向链表

---

 

 在单链表的基础上每个节点增加了一个指针域,指向之前的节点,解决了单链表只能往前不能往后的问题.

四.链表在c#中的实现 

---

LinkedList<T>  双向链表

LinkedListNode<T> 双向链表节点

 

五.面试常见链表相关问题

---

 http://blog.csdn.net/luckyxiaoqiang/article/details/7393134

 

参考文档:

               <大话数据结构>

               

 

 

转载于:https://www.cnblogs.com/Linky008/p/8048135.html