算法大全（1）单链表

声明，本文所有13道算法题目，覆盖了基本上所有常见的单链表问题，全都用C#实现，并测试通过，代码下载：TestLink.zip

 

1.单链表反转

2.找出单链表的倒数第4个元素

3.找出单链表的中间元素

4.删除无头单链表的一个节点

5.两个不交叉的有序链表的合并

6.有个二级单链表，其中每个元素都含有一个指向一个单链表的指针。写程序把这个二级链表称一级单链表。

7.单链表交换任意两个元素（不包括表头）

8.判断单链表是否有环？如何找到环的“起始”点？如何知道环的长度？

9.判断两个单链表是否相交

10.两个单链表相交，计算相交点

11.用链表模拟大整数加法运算

12.单链表排序

13.删除单链表中重复的元素

 

首先写一个单链表的C#实现，这是我们的基石：

public class Link
{
    public Link Next;
    public string Data;
    public Link(Link next, string data)
    {
        this.Next = next;
        this.Data = data;
    }
}

 

其中，我们需要人为地在单链表前面加一个空节点，称其为head。例如，一个单链表是1->2->5，如图所示：

对一个单链表的遍历如下所示：

static void Main(string[] args)
{
    Link head = GenerateLink();
    

    Link curr = head;

    while (curr != null)
    {
        Console.WriteLine(curr.Data);
        curr = curr.Next;
    }
}

 

1.单链表反转

这道题目有两种算法，既然是要反转，那么肯定是要破坏原有的数据结构的：

算法1：我们需要额外的两个变量来存储当前节点curr的下一个节点next、再下一个节点nextnext：

public static Link ReverseLink1(Link head)
{
    Link curr = head.Next;
    Link next = null;
    Link nextnext = null;
    //if no elements or only one element exists
    if (curr == null || curr.Next == null)
    {
        return head;
    }
    //if more than one element
    while (curr.Next != null)
    {
        next = curr.Next;       //1
        nextnext = next.Next;   //2
        next.Next = head.Next;  //3
        head.Next = next;       //4
        curr.Next = nextnext;   //5
    }
    return head;
}

 

算法的核心是while循环中的5句话，画一个图来表示这5个步骤：

 

我们发现，curr始终指向第1个元素。

此外，出于编程的严谨性，还要考虑2种极特殊的情况：没有元素的单链表，以及只有一个元素的单链表，都是不需要反转的。

 

算法2：自然是递归

如果题目简化为逆序输出这个单链表，那么递归是很简单的，在递归函数之后输出当前元素，这样能确保输出第N个元素语句永远在第N+1个递归函数之后执行，也就是说第N个元素永远在第N+1个元素之后输出，最终我们先输出最后一个元素，然后是倒数第2个、倒数第3个，直到输出第1个：

public static void ReverseLink2(Link head)
{
    if (head.Next != null)
    {
        ReverseLink2(head.Next);
        Console.WriteLine(head.Next.Data);
    }
}

但是，现实应用中往往不是要求我们逆序输出（不损坏原有的单链表），而是把这个单链表逆序（破坏型）。这就要求我们在递归的时候，还要处理递归后的逻辑。

首先，要把判断单链表有0或1个元素这部分逻辑独立出来，而不需要在递归中每次都比较一次：

public static Link ReverseLink3(Link head)
{
    //if no elements or only one element exists
    if (head.Next == null || head.Next.Next == null)
        return head;
    head.Next = ReverseLink(head.Next);
    return head;
}

我们观测到：

head.Next = ReverseLink(head.Next);

这句话的意思是为ReverseLink方法生成的逆序链表添加一个空表头。

接下来就是递归的核心算法ReverseLink了：

static Link ReverseLink(Link head)
{
    if (head.Next == null)
        return head;
    Link rHead = ReverseLink(head.Next);
    head.Next.Next = head;
    head.Next = null;
    return rHead;
}

 

算法的关键就在于递归后的两条语句：

head.Next.Next = head;  //1
head.Next = null;       //2

啥意思呢？画个图表示就是：

 

这样，就得到了一个逆序的单链表，我们只用到了1个额外的变量rHead。

 

2.找出单链表的倒数第4个元素

这道题目有两种算法，但无论哪种算法，都要考虑单链表少于4个元素的情况：

第1种算法，建立两个指针，第一个先走4步，然后第2个指针也开始走，两个指针步伐（前进速度）一致。

static Link GetLast4thOne(Link head)
{
    Link first = head;
    Link second = head;
    for (int i = 0; i < 4; i++)
    {
        if (first.Next == null)
            throw new Exception("Less than 4 elements");
        first = first.Next;
    }
    while (first != null)
    {
        first = first.Next;
        second = second.Next;
    }
    return second;
}

 

第2种算法，做一个数组arr[4]，让我们遍历单链表，把第0个、第4个、第8个……第4N个扔到arr[0]，把第1个、第5个、第9个……第4N+1个扔到arr[1]，把第2个、第6个、第10个……第4N+2个扔到arr[2]，把第3个、第7个、第11个……第4N+3个扔到arr[3]，这样随着单链表的遍历结束，arr中存储的就是单链表的最后4个元素，找到最后一个元素对应的arr[i]，让k=(i+1)%4，则arr[k]就是倒数第4个元素。

static Link GetLast4thOneByArray(Link head)
{
    Link curr = head;
    int i = 0;
    Link[] arr = new Link[4];
    while (curr.Next != null)
    {
        arr[i] = curr.Next;
        curr = curr.Next;
        i = (i + 1) % 4;
    }
    if (arr[i] == null)
        throw new Exception("Less than 4 elements");
    return arr[i];
}

 

本题目源代码下载：

推而广之，对倒数第K个元素，都能用以上2种算法找出来。

 

3.找出单链表的中间元素

算法思想：类似于上题，还是使用两个指针first和second，只是first每次走一步，second每次走两步：

static Link GetMiddleOne(Link head)
{
    Link first = head;
    Link second = head;
    while (first != null && first.Next != null)
    {
        first = first.Next.Next;
        second = second.Next;
    }
    return second;
}

但是，这道题目有个地方需要注意，就是对于链表元素个数为奇数，以上算法成立。如果链表元素个数为偶数，那么在返回second的同时，还要返回second.Next也就是下一个元素，它俩都算是单链表的中间元素。

下面是加强版的算法，无论奇数偶数，一概通杀：

static void Main(string[] args)
{
    Link head = GenerateLink();
    bool isOdd = true;
    Link middle = GetMiddleOne(head, ref isOdd);
    if (isOdd)
    {
        Console.WriteLine(middle.Data);
    }
    else
    {
        Console.WriteLine(middle.Data);
        Console.WriteLine(middle.Next.Data);
    }
    Console.Read();
}
static Link GetMiddleOne(Link head, ref bool isOdd)
{
    Link first = head;
    Link second = head;
    while (first != null && first.Next != null)
    {
        first = first.Next.Next;
        second = second.Next;
    }
    if (first != null)
        isOdd = false;
    return second;
}

 

4.一个单链表，很长，遍历一遍很慢，我们仅知道一个指向某节点的指针curr，而我们又想删除这个节点。

这道题目是典型的“狸猫换太子”，如下图所示：

 

如果不考虑任何特殊情况，代码就2行：

curr.Data = curr.Next.Data;
curr.Next = curr.Next.Next;

上述代码由一个地方需要注意，就是如果要删除的是最后一个元素呢？那就只能从头遍历一次找到倒数第二个节点了。

 

此外，这道题目的一个变身就是将一个环状单链表拆开（即删除其中一个元素），此时，只要使用上面那两行代码就可以了，不需要考虑表尾。

相关问题：只给定单链表中某个结点p(非空结点)，在p前面插入一个结点q。

话说，交换单链表任意两个节点，也可以用交换值的方法。但这样就没意思了，所以，才会有第7题霸王硬上工的做法。

 

5.两个不交叉的有序链表的合并

有两个有序链表，各自内部是有序的，但是两个链表之间是无序的。

算法思路：当然是循环逐项比较两个链表了，如果一个到了头，就不比较了，直接加上去。

注意，对于2个元素的Data相等（仅仅是Data相等哦，而不是相同的引用），我们可以把它视作前面的Data大于后面的Data，从而节省了算法逻辑。

static Link MergeTwoLink(Link head1, Link head2)
{
    Link head = new Link(null, Int16.MinValue);
    Link pre = head;
    Link curr = head.Next;
    Link curr1 = head1;
    Link curr2 = head2;
    //compare until one link run to the end
    while (curr1.Next != null && curr2.Next != null)
    {
        if (curr1.Next.Data < curr2.Next.Data)
        {
            curr = new Link(null, curr1.Next.Data);
            curr1 = curr1.Next;
        }
        else
        {
            curr = new Link(null, curr2.Next.Data);
            curr2 = curr2.Next;
        }
        pre.Next = curr;
        pre = pre.Next;
    }
    //if head1 run to the end
    while (curr1.Next != null)
    {
        curr = new Link(null, curr1.Next.Data);
        curr1 = curr1.Next;
        pre.Next = curr;
        pre = pre.Next;
    }
    //if head2 run to the end
    while (curr2.Next != null)
    {
        curr = new Link(null, curr2.Next.Data);
        curr2 = curr2.Next;
        pre.Next = curr;
        pre = pre.Next;
    }
    return head;
}

 

如果这两个有序链表交叉组成了Y型呢，比如说：

这时我们需要先找出这个交叉点（图中是11），这个算法参见第9题，我们这里直接使用第10道题目中的方法GetIntersect。

然后局部修改上面的算法，只要其中一个链表到达了交叉点，就直接把另一个链表的剩余元素都加上去。如下所示：

static Link MergeTwoLink2(Link head1, Link head2)
{
    Link head = new Link(null, Int16.MinValue);
    Link pre = head;
    Link curr = head.Next;
    Link intersect = GetIntersect(head1, head2);
    Link curr1 = head1;
    Link curr2 = head2;
    //compare until one link run to the intersect
    while (curr1.Next != intersect && curr2.Next != intersect)
    {
        if (curr1.Next.Data < curr2.Next.Data)
        {
            curr = new Link(null, curr1.Next.Data);
            curr1 = curr1.Next;
        }
        else
        {
            curr = new Link(null, curr2.Next.Data);
            curr2 = curr2.Next;
        }
        pre.Next = curr;
        pre = pre.Next;
    }
    //if head1 run to the intersect
    if (curr1.Next == intersect)
    {
        while (curr2.Next != null)
        {
            curr = new Link(null, curr2.Next.Data);
            curr2 = curr2.Next;
            pre.Next = curr;
            pre = pre.Next;
        }
    }
    //if head2 run to the intersect
    else if (curr2.Next == intersect)
    {
        while (curr1.Next != null)
        {
            curr = new Link(null, curr1.Next.Data);
            curr1 = curr1.Next;
            pre.Next = curr;
            pre = pre.Next;
        }
    }
    return head;
}

 

6.有个二级单链表，其中每个元素都含有一个指向一个单链表的指针。写程序把这个二级链表展开称一级单链表。

这个简单，就是说，这个二级单链表只包括一些head：

public class Link
{
    public Link Next;
    public int Data;
    public Link(Link next, int data)
    {
        this.Next = next;
        this.Data = data;
    }
}
public class CascadeLink
{
    public Link Next;
    public CascadeLink NextHead;
    public CascadeLink(CascadeLink nextHead, Link next)
    {
        this.Next = next;
        this.NextHead = nextHead;
    }
}

 

下面做一个二级单链表，GenerateLink1和GenerateLink2方法在前面都已经介绍过了：

public static CascadeLink GenerateCascadeLink()
{
    Link head1 = GenerateLink1();
    Link head2 = GenerateLink2();
    Link head3 = GenerateLink1();
    CascadeLink element3 = new CascadeLink(null, head3);
    CascadeLink element2 = new CascadeLink(element3, head2);
    CascadeLink element1 = new CascadeLink(element2, head1);
    CascadeLink head = new CascadeLink(element1, null);
    return head;
}

就是说，这些单链表的表头head1、head2、head3、head4……，它们组成了一个二级单链表head：null –> head1 –> head2 –> head3 –> head4  –> 

 

我们的算法思想是： 进行两次遍历，在外层用curr1遍历二级单链表head，在内层用curr2遍历每个单链表：

public static Link GenerateNewLink(CascadeLink head)
{
    CascadeLink curr1 = head.NextHead;
    Link newHead = curr1.Next;
    Link curr2 = newHead;
    while (curr1 != null)
    {
        curr2.Next = curr1.Next.Next;
        while (curr2.Next != null)
        {
            curr2 = curr2.Next;
        }
        curr1 = curr1.NextHead;
    }
    return newHead;
}

其中，curr2.Next = curr1.Next.Next; 这句话是关键，它负责把上一个单链表的表尾和下一个单链表的非空表头连接起来。 

 

7.单链表交换任意两个元素（不包括表头）

先一次遍历找到这两个元素curr1和curr2，同时存储这两个元素的前驱元素pre1和pre2。

然后大换血

public static Link SwitchPoints(Link head, Link p, Link q)
{
    if (p == head || q == head)
        throw new Exception("No exchange with head");
    if (p == q)
        return head;
    //find p and q in the link
    Link curr = head;
    Link curr1 = p;
    Link curr2 = q;
    Link pre1 = null;
    Link pre2 = null;
    
    int count = 0;

    while (curr != null)
    {
        if (curr.Next == p)
        {
            pre1 = curr;
            count++;
            if (count == 2)
                break;
        }
        else if (curr.Next == q)
        {
            pre2 = curr;
            count++;
            if (count == 2)
                break;
        }
        curr = curr.Next;
    }
    curr = curr1.Next;
    pre1.Next = curr2;
    curr1.Next = curr2.Next;
    pre2.Next = curr1;
    curr2.Next = curr;
    return head;
}

注意特例，如果相同元素，就没有必要交换；如果有一个是表头，就不交换。

 

8.判断单链表是否有环？如何找到环的“起始”点？如何知道环的长度？

算法思想：

先分析是否有环。为此我们建立两个指针，从header一起向前跑，一个步长为1，一个步长为2，用while（直到步长2的跑到结尾）检查两个指针是否相等，直到找到为止。

static bool JudgeCircleExists(Link head)
{
    Link first = head;  //1 step each time
    Link second = head; //2 steps each time
    while (second.Next != null && second.Next.Next != null)
    {
        second = second.Next.Next;
        first = first.Next;
        if (second == first)
            return true;
    }
    return false;
}

 

那又如何知道环的长度呢？

根据上面的算法，在返回true的地方，也就是2个指针相遇处，这个位置的节点P肯定位于环上。我们从这个节点开始先前走，转了一圈肯定能回来：

static int GetCircleLength(Link point)
{
    int length = 1;
    Link curr = point;
    while (curr.Next != point)
    {
        length++;
        curr = curr.Next;
    }
     return length;
}

 

继续我们的讨论，如何找到环的“起始”点呢？

延续上面的思路，我们仍然在返回true的地方P，计算一下从有环单链表的表头head到P点的距离

static int GetLengthFromHeadToPoint(Link head, Link point)
{
    int length = 1;
    Link curr = head;
    while (curr != point)
    {
        length++;
        curr = curr.Next;
    }
    return length;
}

如果我们把环从P点“切开”（当然并不是真的切，那就破坏原来的数据结构了），那么问题就转化为计算两个相交“单链表”的交点（第10题）：

一个单链表是从P点出发，到达P（一个回圈），距离M；另一个单链表从有环单链表的表头head出发，到达P，距离N。

我们可以参考第10题的GetIntersect方法并稍作修改。

private static Link FindIntersect(Link head)
{
    Link p = null;
    //get the point in the circle
    bool result = JudgeCircleExists(head, ref p);
    if (!result) return null;
    Link curr1 = head.Next;
    Link curr2 = p.Next;
    //length from head to p
    int M = 1;
    while (curr1 != p)
    {
        M++;
        curr1 = curr1.Next;
    }
    //circle length
    int N = 1;
    while (curr2 != p)
    {
        N++;
        curr2 = curr2.Next;
    }
    //recover curr1 & curr2
    curr1 = head.Next;
    curr2 = p.Next;
    //make 2 links have the same distance to the intersect
    if (M > N)
    {
        for (int i = 0; i < M - N; i++)
            curr1 = curr1.Next;
    }
    else if (M < N)
    {
        for (int i = 0; i < N - M; i++)
            curr2 = curr2.Next;
    }
    //goto the intersect
    while (curr1 != p)
    {
        if (curr1 == curr2)
        {
            return curr1;
        }
        curr1 = curr1.Next;
        curr2 = curr2.Next;
    }
    return null;
}

 

9.判断两个单链表是否相交

这道题有多种算法。

算法1：把第一个链表逐项存在hashtable中，遍历第2个链表的每一项，如果能在第一个链表中找到，则必然相交。

static bool JudgeIntersectLink1(Link head1, Link head2)
{
    Hashtable ht = new Hashtable();
    Link curr1 = head1;
    Link curr2 = head2;
    //store all the elements of link1
    while (curr1.Next != null)
    {
        ht[curr1.Next] = string.Empty;
        curr1 = curr1.Next;
    }
    //check all the elements in link2 if exists in Hashtable or not
    while (curr2.Next != null)
    {
        //if exists
        if (ht[curr2.Next] != null)
        {
            return true;
        }
        curr2 = curr2.Next;
    }
    return false;
}

算法2：把一个链表A接在另一个链表B的末尾，如果有环，则必然相交。如何判断有环呢？从A开始遍历，如果能回到A的表头，则肯定有环。

注意，在返回结果之前，要把刚才连接上的两个链表断开，恢复原状。

static bool JudgeIntersectLink2(Link head1, Link head2)
{
    bool exists = false;
    Link curr1 = head1;
    Link curr2 = head2;
    
    //goto the end of the link1
    while (curr1.Next != null)
    {
        curr1 = curr1.Next;
    }
    //join these two links
    curr1.Next = head2;
    //iterate link2
    while (curr2.Next != null)
    {
        if (curr2.Next == head2)
        {
            exists = true;
            break;
        }
        curr2 = curr2.Next;
    }
    //recover original status, whether exists or not
    curr1.Next = null;
    return exists;
}

算法3：如果两个链表的末尾元素相同，则必相交。

static bool JudgeIntersectLink3(Link head1, Link head2)
{
    Link curr1 = head1;
    Link curr2 = head2;
    //goto the end of the link1
    while (curr1.Next != null)
    {
        curr1 = curr1.Next;
    }
    //goto the end of the link2
    while (curr2.Next != null)
    {
        curr2 = curr2.Next;
    }
    if (curr1 != curr2)
        return false;
    else
        return true;
}

 

10.两个单链表相交，计算相交点

分别遍历两个单链表，计算出它们的长度M和N，假设M比N大，则长度M的链表先前进M-N，然后两个链表同时以步长1前进，前进的同时比较当前的元素，如果相同，则必是交点。

public static Link GetIntersect(Link head1, Link head2)
{
    Link curr1 = head1;
    Link curr2 = head2;
    int M = 0, N = 0;
    //goto the end of the link1
    while (curr1.Next != null)
    {
        curr1 = curr1.Next;
        M++;
    }
    //goto the end of the link2
    while (curr2.Next != null)
    {
        curr2 = curr2.Next;
        N++;
    }
    //return to the begining of the link
    curr1 = head1;
    curr2 = head2;
    if (M > N)
    {
        for (int i = 0; i < M - N; i++)
            curr1 = curr1.Next;
    }
    else if (M < N)
    {
        for (int i = 0; i < N - M; i++)
            curr2 = curr2.Next;
    }
    while (curr1.Next != null)
    {
        if (curr1 == curr2)
        {
            return curr1;
        }
        curr1 = curr1.Next;
        curr2 = curr2.Next;
    }
    return null;
}

 

11.用链表模拟大整数加法运算

例如：9>9>9>NULL + 1>NULL =>  1>0>0>0>NULL

肯定是使用递归啦，不然没办法解决进位+1问题，因为这时候要让前面的节点加1，而我们的单链表是永远指向前的。

此外对于999+1=1000，新得到的值的位数（4位）比原来的两个值（1个1位，1个3位）都多，所以我们将表头的值设置为0，如果多出一位来，就暂时存放到表头。递归结束后，如果表头为1，就在新的链表外再加一个新的表头。

//head1 length > head2, so M > N
public static int Add(Link head1, Link head2, ref Link newHead, int M, int N)
{
    // goto the end
    if (head1 == null)
        return 0;
    int temp = 0;
    int result = 0;
    newHead = new Link(null, 0);
    if (M > N)
    {
        result = Add(head1.Next, head2, ref newHead.Next, M - 1, N);
        temp = head1.Data + result;
        newHead.Data = temp % 10;
        return temp >= 10 ? 1 : 0;
    }
    else // M == N
    {
        result = Add(head1.Next, head2.Next, ref newHead.Next, M - 1, N - 1);
        temp = head1.Data + head2.Data + +result;
        newHead.Data = temp % 10;
        return temp >= 10 ? 1 : 0;
    }
}

这里假设head1比head2长，而且M、N分别是head1和head2的长度。

 

12.单链表排序

无外乎是冒泡、选择、插入等排序方法。关键是交换算法，需要额外考虑。第7题我编写了一个交换算法，在本题的排序过程中，我们可以在外层和内层循环里面，捕捉到pre1和pre2，然后进行交换，而无需每次交换又要遍历一次单链表。

在实践中，我发现冒泡排序和选择排序都要求内层循环从链表的末尾向前走，这明显是不合时宜的。

所以我最终选择了插入排序算法，如下所示：

先给出基于数组的算法： 

        static int[] InsertSort(int[] arr)
        {
            for (int i = 1; i < arr.Length; i++)
            {
                for (int j = i; (j > 0) && arr[j] < arr[j - 1]; j--)
                {
                    arr[j] = arr[j] ^ arr[j - 1];
                    arr[j - 1] = arr[j] ^ arr[j - 1];
                    arr[j] = arr[j] ^ arr[j - 1];
                }
            }

            return arr;
        }

  

仿照上面的思想，我们来编写基于Link的算法：

public static Link SortLink(Link head)
{
    Link pre1 = head;
    Link pre2 = head.Next;
    Link min = null;
    for (Link curr1 = head.Next; curr1 != null; curr1 = min.Next)
    {
        if (curr1.Next == null)
            break;
        min = curr1;
        for (Link curr2 = curr1.Next; curr2 != null; curr2 = curr2.Next)
        {
            //swap curr1 and curr2
            if (curr2.Data < curr1.Data)
            {
                min = curr2;
                curr2 = curr1;
                curr1 = min;
                pre1.Next = curr1;
                curr2.Next = curr1.Next;
                curr1.Next = pre2;
                //if exchange element n-1 and n, no need to add reference from pre2 to curr2, because they are the same one
                if (pre2 != curr2)
                    pre2.Next = curr2;
            }
            pre2 = curr2;
        }
        pre1 = min;
        pre2 = min.Next;
    }
    return head;
}

 

值得注意的是，很多人的算法不能交换相邻两个元素，这是因为pre2和curr2是相等的，如果此时还执行pre2.Next = curr2; 会造成一个自己引用自己的环。

 

交换指针很是麻烦，而且效率也不高，需要经常排序的东西最好不要用链表来实现，还是数组好一些。

 

13.删除单链表中重复的元素

用Hashtable辅助，遍历一遍单链表就能搞定。

实践中发现，curr从表头开始，每次判断下一个元素curr.Netx是否重复，如果重复直接使用curr.Next = curr.Next.Next; 就可以删除重复元素——这是最好的算法。唯一的例外就是表尾，所以到达表尾，就break跳出while循环。

public static Link DeleteDuplexElements(Link head)
{
    Hashtable ht = new Hashtable();
    Link curr = head;
    while (curr != null)
    {
        if (curr.Next == null)
        {
            break;
        }
        if (ht[curr.Next.Data] != null)
        {
            curr.Next = curr.Next.Next;
        }
        else
        {
            ht[curr.Next.Data] = "";
        }
        curr = curr.Next;
    }
    return head;
}

 

 

结语：

单链表只有一个向前指针Next，所以要使用1-2个额外变量来存储当前元素的前一个或后一个指针。

尽量用while循环而不要用for循环，来进行遍历。

哇塞，我就是不用指针，照样能“修改地址”，达到和C++同样的效果，虽然很烦~

遍历的时候，不要在while循环中head=head.Next;这样会改变原先的数据结构。我们要这么写：Link curr=head;然后curr=curr.Next;

有时我们需要临时把环切开，有时我们需要临时把单链表首尾相连成一个环。

究竟是玩curr还是curr.Next，根据不同题目而各有用武之地，没有定论，不必强求。