HackerRank-Data Structure-linked list

欢迎留言指正，我会及时修改

题目的难度都是Easy，也就是些基本操作的实现，没有难度。
特别说明一下，这些题目只要求实现对应某一个函数或功能，故只有代码片段

Insert a node at the tail of a linked list
解决思路：尾插法的实现
难度：Easy

Node* Insert(Node *head, int data)
{
    Node *tail,*temp_of_head=head;
    if (head == NULL)
    {
        Node *head = (Node*)malloc(sizeof(Node));
        head->data = data;
        head->next = NULL;
        return head;
    }
    while (head->next != NULL)
        head = head->next;
    tail = (Node*)malloc(sizeof(Node));
    tail->data = data;
    tail->next = NULL;
    head->next = tail;
    return temp_of_head;
}

Print the elements of a linked list
解决思路：遍历单向链表
难度：Easy

void Print(Node *head)
{
    Node *temp = head;
    while (temp != NULL)
    {
        cout << temp->data << endl;
        temp = temp->next;
    }
}

Insert a node at the head of a linked list
解决思路：头插法的实现
难度：Easy

Node* Insert(Node *head, int data)
{
    Node *New_head;
    New_head = (Node*)malloc(sizeof(Node));
    New_head->data = data;
    New_head->next = head;
    return New_head;
}

Insert a node at a specific position
解决思路：遍历链表并查找插入点
难度：Easy

Node* InsertNth(Node *head, int data, int position)
{
    int i = 0;
    Node *Insert_Node,*temp_of_head=head,*temp_of_next;
    Insert_Node = (Node*)malloc(sizeof(Node));
    Insert_Node->data = data;
    Insert_Node->next = NULL;
    if (position == 0)
    {
        Insert_Node->next = head;
        return Insert_Node;
    }
    while (i < position-1)
    {
        head = head->next;
        i++;
    }
    temp_of_next = head->next;
    head->next = Insert_Node;
    Insert_Node->next = temp_of_next;
    return temp_of_head;
}

Delete a Node
解决思路：遍历链表，查找删除点
难度：Easy

Node* Delete(Node *head, int position)
{
    int i = 0;
    Node *temp_of_head=head;
    if (head == NULL)
        return NULL;
    if (position == 0)
        return head->next;
    while (i < position - 1)
    {
        head = head->next;
        i++;
    }
    head->next = (head->next)->next;
    return temp_of_head;
}

Print in Reverse
解决思路：遍历时用，用一个数组记录，之后反向输出
难度：Easy

void ReversePrint(Node *head)
{
    int i = 0;

    while (head != NULL)
    {
        array[i] = head->data;
        head = head->next;
        i++;
    }
    for (int j = i-1; j >= 0; j--)
        printf("%d\n", array[j]);
}

Reverse a linked list
解决思路：遍历时用数组记录数据，并反向赋值
难度：Easy

Node* Reverse(Node *head)
{
    int i = 0, j = 0, array[100];
    Node *temp1 = head;
    Node *temp2 = head;
    while (temp1 != NULL)
    {
        array[i] = temp1->data;
        temp1 = temp1->next;
        i++;
    }
    for ( j = i-1; j >= 0; j--)
    {
        temp2->data = array[j];
        temp2 = temp2->next;
    }


    while (head != NULL)
    {
        printf("%d ", head->data);
        head = head->next;
    }
    return head;
}

Compare two linked lists
解决思路：遍历并比较
难度：Easy

int CompareLists(Node *headA, Node* headB)
{
    if (headA == NULL && headB == NULL)
        return 1;
    while (headA != NULL &&headB != NULL)
    {
        if (headA->data == headB->data)
        {
            headA = headA->next;
            headB = headB->next;
        }
        else
            return 0;
    }
    if (headA == NULL && headB == NULL)
        return 1;
    else
        return 0;
}

Get Node Value
解决思路：依旧靠数组
难度：Easy

int GetNode(Node *head, int positionFromTail)
{
    int i = 0;
    int array[100];
    while (head != NULL){
        array[i++] = head->data;
        head = head->next;
    }
    return array[i-positionFromTail];
}

Merge two sorted linked lists
解决思路：递归的合并链表
难度：Easy

Node* MergeLists(Node *headA, Node* headB)
{
    if (headA == NULL)
        return headB;
    else if (headB == NULL)
        return headA;
    else
    {
        if (headA->data <= headB->data)
        {
            headA->next = MergeLists(headA->next, headB);
            return headA;
        }
        else
        {
            headB->next = MergeLists(headA, headB->next);
            return headB;
        }
    }
}

Delete duplicate-value nodes from a sorted linked list
思路：由于重复元素连续出现，遍历就可以了
难度：Easy

Node* RemoveDuplicates(Node *head)
{
    Node *temp=head;
    while (head->next != NULL)
    {
        if (head->data == head->next->data)
            head->next = head->next->next;
        else
        head = head->next;
    }
    return temp;
}

Detect Cycle
思路：用两个指针分别用不同的速度前进，一旦某时刻二者指向同一节点，则说明链表有环（解决这个问题的方法在网上可以找到很多，我选了一种简单易懂的方法）
难度：Easy

int HasCycle(Node* head)
{
    Node *one = head;
    Node *two = head;
    if (head == NULL)
        return 0;
    while (1){
        if (one->next == NULL)
            return 0;
        else
            one = one->next;
        if ((two->next)->next == NULL)
            return 0;
        else
            two = (two->next)->next;
        if (one == two)
            return 1;
    }
}

Find Merge Point of Two Lists
解决思路：每次都遍历其中一条链表，查找是否有节点与另一条链表的节点相同，每次
遍历之后前进一个节点，继续下次遍历
难度：Easy

int FindMergeNode(Node *headA, Node *headB)
{
    Node *TempB = headB;
    while (TempB != NULL)
    {
        Node *TempA = headA;
        while (TempA!=NULL)
        {
            if (TempA == TempB)
                return TempA->data;
            else
                TempA = TempA->next;
        }
        TempB = TempB->next;
    }
}

Insert a node into a sorted doubly linked list
解决思路：双向链表的插入的实现，综合出现了头插法尾插法及一般情况的考察
难度：Easy

Node* SortedInsert(Node *head, int data)
{
    Node *temp_of_prev=head;
    Node *temp_of_head = head;
    Node *Insert_Node =new Node();
    Insert_Node->data = data;
    Insert_Node->next = NULL;
    Insert_Node->prev = NULL;

    if (head == NULL)
        return Insert_Node;
    while (temp_of_head != NULL && temp_of_head->data <= data)
        temp_of_head = temp_of_head->next;
    if (temp_of_head == NULL)
    {
        while (temp_of_prev->next != NULL)
            temp_of_prev = temp_of_prev->next;
        temp_of_prev->next = Insert_Node;
        Insert_Node->prev = temp_of_prev;
        return head;
    }
    temp_of_prev = temp_of_head->prev;
    if (temp_of_prev == NULL)
    {
        Insert_Node->next = head;
        head->prev = Insert_Node;
        return Insert_Node;
    }
    temp_of_prev->next = Insert_Node;
    Insert_Node->prev = temp_of_prev;
    Insert_Node->next = temp_of_head;
    temp_of_head->prev = Insert_Node;

    return head;

}

Reverse a doubly linked list
解决思路：还是靠数组记录所有元素，最后反向赋值
难度：Easy

Node* Reverse(Node* head)
{
    int i = 0, array[1000];
    Node *one = head,*two=head;
    if (head == NULL)
        return NULL;
    while (one != NULL)
    {
        array[i++]=one->data;
        one = one->next;
    }
    for (int j = i-1; j >=0 ; j--)
    {
        two->data=array[j];
        two = two->next;
    }
    return head;
}