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;
}