标签：node cur 终结 List headRef next data Linked struct

第一篇终结Linked List（一）、终结Linked List（二）主要讲了单链表的基础知识，接下来的第二篇主要讲一些比较经典的问题。

一、Count()

给一个单链表和一个整数，返回这个整数在链表中出现了多少次。

/*
Given a list and an int, return the number of times 
that int ocucurs in the list.
*/
int Count(struct node* head,int searchFor)
{
    int cnt = 0;
    struct node* cur = head;

    while (cur != NULL)
    {
        if (cur->data == searchFor)
            cnt++;
        cur = cur->next;
    }

    return cnt;
}

也可以用for循环实现。

二、GetNth()

给一个单链表和一个index，返回index位置上的数值，类似array[index]操作。

/*
Given a list and an index, return the data in the nth
node of the list. The nodes are numbered from 0.
Assert fails if the index is invalid (outside 0..length - 1).
*/
int GetNth(struct node* head,int index)
{
    int len = 0;
    struct node* cur = head;

    while (cur)
    {
        if (len == index)
        {
            return cur->data;
        }
        cur = cur->next;
        len++;
    }

    assert(0);  //如果走到这一行，表达式的值为假，断言失败
}

三、DeleteList()

给一个单链表，删除所有节点，使head为NULL。
删除链表{1,2,3}的示意图：

void DeleteList(struct node** headRef)
{
    struct node* cur = *headRef;  //deref headRef to get the real head

    while (*headRef)
    {
        cur = *headRef;
        *headRef = cur->next;
        free(cur);
    }
}

四、Pop()

给一个链表，删掉头节点，返回头节点的数据。
内存示意图：

/*
The opposite of Push().Takes a non-empty list and 
remove the front node, and returns the data which was in that node.
*/
int pop(struct node** headRef)
{
    assert(*headRef != NULL);
    int ans = (*headRef)->data;  //pull out the data before the node is deleted

    struct node* cur = *headRef;
    *headRef = (*headRef)->next;   //unlink the head node for the caller
    free(cur);    //free the head node

    return ans;
}

五、InsertNth()

可以在[0,length]的任意位置插入指定元素。

/*
A more general version of Push().
Given a list, an index 'n' in the range 0..length,
and a data element, add a new node to the list so that
it has the given index.
*/
void InsertNth(struct node** headRef,int index,int data)
{
    //position 0 is a special case
    if (index == 0)
    {
        Push(headRef, data);
    }
    else
    {
        int cnt = 0;
        struct node* cur = *headRef;

        while (cnt < index - 1)
        {
            assert(cur != NULL);   //if this fails, the index was too big
            cur = cur->next;
            cnt++;
        }

        assert(cur != NULL);    //tricky:you have to check one last time

        Push(&(cur->next), data);
    }
}

这段代码坑有点多，可以通过画图或者单步跟踪的方法调试。
InsertNthTest()可以用来测试：

void InsertNthTest()
{
    struct node* head = NULL;   //start with the empty list
     
    InsertNth(&head, 0, 13);   //{13}
    InsertNth(&head, 1, 42);    //{13,42}
    InsertNth(&head, 1, 5);     //{13,5,42}
}

六、SortedInsert()

给定一个有序链表和一个节点，将该节点插入到合适的位置。
共有三种方法：
1、Uses special case code for the head end

void SortedInsert(struct node** headRef,struct node* newNode)
{
    //Special case for the head end
    if (newNode->data <= (*headRef)->data || *headRef == NULL)
    {
        newNode->next = *headRef;
        *headRef = newNode;
    }
    else
    {
        //Locate the node before the point of insertion
        struct node* cur = *headRef;
        while (cur->next && cur->next->data < newNode->data)
        {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
    }
}

2、Dummy node strategy for the head end
用dummy node这种方法一般不需要处理特殊情况。

void SortedInsert2(struct node** headRef,struct node* newNode)
{
    struct node dummy;
    struct node* cur = &dummy;      
    dummy.next = *headRef;

    while (cur->next && newNode->data >= cur->next->data)
    {
        cur = cur->next;
    }
    newNode->next = cur->next;
    cur->next = newNode;

    *headRef = dummy.next;  //头指针永远指向dummy.next
}

3、Local references strategy for the head end

void SortedInsert3(struct node** headRef,struct node* newNode)
{
    struct node** curRef = headRef;

    while (*curRef && (*curRef)->data <= newNode->data)
    {
        curRef = &((*curRef)->next);
    }

    newNode->next = *curRef;  //Bug:(*curRef)->next  is incorrect

    *curRef = newNode;
}

标签：node,cur,终结,List,headRef,next,data,Linked,struct
来源： https://www.cnblogs.com/EIMadrigal/p/12234295.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。