数据结构 单链表相关习题练习

1.逆序打印单链表

采用递归的方法即可实现。

//逆序打印单链表
void LinkListReversePrint(LinkNode* head)
{
    if(head == NULL)
    {   
        return;
    }   
    LinkListReversePrint(head->next);
    printf("[%c]  ",head->data);
}

2.不允许遍历链表, 在 pos之前插入

在pos之前插入不好实现，可以换个思路，将新节点插入pos之后，将pos的值赋给新节点，同时将value赋给pos。

// 不允许遍历链表, 在 pos之前插入 
void LinkListInsertBefore(LinkNode** head, LinkNode* pos, LinkType value)
{
    if(head == NULL)
    {   
        //非法输入
        return;
    }   
    if(*head == NULL)
    {   
        *head = CreateNode(value);
        return;
    }   
    if(pos == NULL)
    {   
        return;
    }   
    if(pos == *head)
    {
        LinkListPushFront(head,value);
        return;
    }
    LinkNode* new_node = CreateNode(pos->data);
    LinkNode* next = pos->next;
    pos->next = new_node;
    new_node->next = next;
    pos->data = value;
    return;
}

3.单链表逆置

//单链表逆置
void LinkListReverse2(LinkNode** head)
{
    if(head == NULL)
    {   
        //非法输入
        return;
    }   
    if(*head == NULL)
    {   
        //空链表
        return;
    }   
    LinkNode* cur = *head;
    LinkNode* newHead = NULL;
    while(cur != NULL)
    {   
        LinkNode* tmp = cur;
    
        cur = cur->next;
        //头插
        tmp->next = newHead;
        newHead = tmp;
    }   
    *head = newHead;
    return;
}

4.单链表的冒泡排序(升序）

  

void LinkListBubbleSort(LinkNode* head)
{
    if(head == NULL || head->next == NULL)  
    {   
        return;
    }   
    LinkNode* cur,*next;
    LinkNode* tail = NULL;
    while(tail != head->next)
    {   
        cur = head;
        next = head->next;
        while(next != tail)
        {   
            if(cur->data > next->data)  
            {   
                LinkType tmp = cur->data;
                cur->data = next->data;
                next->data = tmp;
            }   
            cur = cur->next;
            next = next->next;
        }   
        tail = cur;
    }   
}

5.合并两有序单链表

//合并两有序单链表
LinkNode* LinkListMerge(LinkNode* head1, LinkNode* head2)
{
    if(head1 == NULL)
    {
        return head2;
    }
    if(head2 == NULL)
    {
        return head1;
    }
    LinkNode* cur;
    if(head1->data > head2->data)
    {
        cur = head2;
        head2 = head2->next;
    }
    else
    {
        cur = head1;
        head1 = head1->next;
    }
    LinkNode* tail = cur;
    while(head1 != NULL && head2 != NULL)
    {
        if(head1->data <= head2->data)
        {
            tail->next = head1;
            head1 = head1->next;
        }
        else
        {
            tail->next = head2;
            head2 = head2->next;
        }   
        tail = tail->next;  
    }   
    if(head1 != NULL)
    {   
        while(head1)
        {
            tail->next = head1;
            tail = tail->next;
            head1 = head1->next;
        }
    }
    if(head2 != NULL)
    {
        while(head2)
        {
            tail->next = head2;
            tail = tail->next;
            head2 = head2->next;
        }
    }
    return cur;
}

6.删除倒数第k个结点

//删除倒数第k个结点
void EraseLastKNode(LinkNode** head, size_t K)
{
	if(head == NULL)
	{
		//非法输入
		return;
	}
	if(*head == NULL)
	{
		//空链表
		return;
	}
	int count = 0;
	LinkNode* cur = *head;
	while(cur != NULL)
	{
		count++;	
		cur = cur->next;
	}
	if(K == count)
	{
		LinkListPopFront(head);
		return;
	}
	if(K < 0 || K >count)
	{
		return;
	}
	//删除自身结点不好删除，可以把该结点的next结点的data拷贝到该结点，然后删除下一个结点
	LinkNode* fast = *head;
	LinkNode* low = *head;
	size_t i = 0;
	for(;i<K-1;i++)
	{
		fast = fast->next;
	}
	while(fast->next != NULL)
	{
		low = low->next;
		fast = fast->next;
	}
	LinkNode* to_delete = low->next;
	low->data = to_delete->data;
	low->next = to_delete->next;
	DestroyNode(to_delete);
}