链表笔试题1

最新推荐文章于 2022-12-02 17:27:06 发布
最新推荐文章于 2022-12-02 17:27:06 发布
阅读量174 收藏
点赞数
分类专栏： Linux 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alsnoa/article/details/80016758
版权 
#include "linkedlist.h"
/** 
 *  * @brief 逆序打印单链表. 
 *   * 
 *    * @param head 
 *     */ 
void LinkListReversePrint(LinkNode* head)
{
      if(head==NULL)
      {
          return;
      }
      LinkListReversePrint(head->next);
      printf("%c<-");

}

/** 
 *  * @brief 不允许遍历链表, 在 pos之前插入 
 *  * 
 *   * @param head 
 *    * @param pos 
 *     * @param value 
 *      */ 
void LinkListInsertBefore(LinkNode** head, LinkNode* pos, LinkType value)
{
    if(head==NULL)
    {
        return;
    }
    if(*head==NULL)
    {
        return;
    }
    if(pos==NULL)
    {
        return;
    }
    LinkNode*cur=(LinkNode*)malloc(sizeof(LinkNode));
    cur->data=pos->data;
    cur->next=pos->next;
    pos->data=value;
    pos->next=cur;
}

LinkNode* JosephCycle(LinkNode* head, size_t food)
{
  if(head==NULL)
  {
    printf("The head pointer is NULL!");
    return;
  }
    LinkNode* to_delete=NULL;
    size_t i=0;
    while(head!=head->next)
    {
        for(i=1;i<food;i++)
        {
            head=head->next;
        }      
        
        to_delete=head->next;
       head->data=to_delete->data;
       head->next=to_delete->next;
       free(to_delete);
       to_delete=NULL;
    }
    return head;
}

/** 
 *  * @brief 单链表逆置 
 *  * 
 *   * @param head 
 *    */ 
void LinkListReverse(LinkNode** head)
{

      if(head==NULL)
    {
        return;
    }
      if(*head==NULL)
    {
        return;
    }

    LinkNode* top=NULL;
    LinkNode* to_delete=NULL;
    LinkNode* pre=NULL;
    LinkNode* cur=NULL; 
    top=*head;
    pre=*head;
    cur=(*head)->next;

   while(cur!=NULL)
 {
    
    to_delete=cur;
    pre->next= to_delete->next;
    to_delete->next=top;
    top=to_delete;
    pre=cur;
    cur=cur->next;
    
 }
  *head=top;
}
//void LinkListReverse2(LinkNode** head)
/** 
 *  * @brief 单链表的冒泡排序 
 *  * 
 *   * @param head 
 *    */ 
void LinkListBubbleSort(LinkNode* head)
{
  if(head==NULL)
  {
      return;
  }
    LinkNode* cur=NULL;
    LinkNode* tail=NULL;
    cur=head;
    while(cur!=tail)
    {
        while(cur->next!=tail)
        {
            if(cur->data>cur->next->data)
            {
                char tmp=cur->data;
                cur->data=cur->next->data;
                cur->next->data=tmp;

            }
            cur=cur->next;
        }
        tail=cur;
        cur=head;
    }
}

/** 
 *  * @brief 将两个有序链表, 合并成一个有序链表 
 *  * 
 *   * @param head1 
 *    * @param head2 
 *     * 
 *      * @return 
 *       */ 
LinkNode* LinkListMerge(LinkNode* head1, LinkNode* head2)
{
  LinkNode* first=NULL;
  LinkNode* tail =NULL;

      first=(head1->data>head2->data? head2:head1);
      tail=first; 
      while(head1!=NULL && head2!=NULL)
    {
     if(head1->data<=head2->data)
      {
         tail->next=head1;
         head1=head1->next;
      }

      else if(head1->data>head2->data)
      {
          tail->next =head2;
          head2=head2->next;
      }

    }       
      if(head1==NULL)
      {
          tail->next=head2;
      }
      else if(head2=NULL)
      {
          tail->next=head2;
      }
     return first;
}

/** 
 *  * @brief 找到倒数第 K 个节点. 
 *   * 
 *    * @param head 
 *     * 
 *      * @return 
 *       */ 
LinkNode* FindLastKNode(LinkNode* head, size_t K)
{
  LinkNode*cur=head;
  LinkNode*fast=NULL;
  LinkNode*slow=head;

  size_t i=0;
  for(i=1;i<K;i++)
  {
    cur=cur->next; 
  } 
    fast=cur;
    while(fast->next!=NULL)
    {
       slow=slow->next;
       fast=fast->next;
    }
    return slow;
}

/** 
 *  * @brief 删除倒数第K个节点 
 *  * 
 *   * @param head 
 *    * @param K 
 *     */ 
void EraseLastKNode(LinkNode** head, size_t K)
{
if(head==NULL)
{
    return;
}
  if(*head==NULL)
{
    return;
}
  LinkNode*cur=*head;
  LinkNode*fast=NULL;
  LinkNode*slow=*head;
  LinkNode*pre=NULL;
  size_t i=0;
  for(i=1;i<K;i++)
  {
    cur=cur->next; 
  } 
    fast=cur;
    while(fast->next!=NULL)
    {
        pre=slow;
       slow=slow->next;
       fast=fast->next;
    }
    if(pre==NULL)
    {
        pre=*head;
        *head=(*head)->next;
        free(pre);
    }else
    {
     pre->next=slow->next;
     free(slow);
    }
}

/** 
 *  * @brief 判定单链表是否带环. 如果带环返回1 
 *   * 
 *    * @param head 
 *     * 
 *      * @return 
 *       */ 
LinkNode* HasCycle(LinkNode* head)
{
  if(head==NULL)
  {
      return;
  }
  LinkNode*fast=head;
  LinkNode*slow=head;
  while(fast->next!=NULL && fast->next->next!=NULL)
  {

    slow=slow->next;
    fast=fast->next->next;
     if(slow==fast)
     {
       printf("Hascycle");
       return slow; 
     }

  }  
  return NULL;

}

/** 
 *  * @brief 如果链表带环, 求出环的长度 
 *  * 
 *   * @param head 
 *    * 
 *     * @return 
 *      */ 
size_t GetCycleLen(LinkNode* head)
{
  LinkNode*pos=HasCycle(head);
  LinkNode*cur=pos;
  cur=cur->next;
  size_t i=1;
  while(cur!=pos)
  {
    cur=cur->next;
    i++;

  }
return i;
}

/** 
 *  * @brief 如果链表带环, 求出环的入口 
 *  * 
 *   * @param head 
 *    * 
 *     * @return 
 *      */ 
LinkNode* GetCycleEntry(LinkNode* head)
{
  if(head==NULL) 
  {
      return;
  }
  LinkNode* pos =HasCycle(head);
  LinkNode*first=head;
  if(pos==NULL)
  {
      return NULL;
  }
  while(first!=pos)
  {
      first=first->next;
      pos=pos->next;

  }

return pos;

}

/** 
 *  * @brief 判定两个链表是否相交, 并求出交点 
 *  * 
 *   * @param head1 
 *    * @param head2 
 *     * 
 *      * @return 
 *       */ 
LinkNode* HasCross(LinkNode* head1, LinkNode* head2)
{
     if(head1==NULL)
     {
         return ;
     }
     if(head2==NULL)
     {
         return ;
     }
     size_t count1=0;
     size_t count2=0;
     LinkNode*pos1=HasCycle(head1);
     LinkNode*pos2=HasCycle(head2);

     //Two no cycle linkedlist.
     if(pos1==NULL && pos2==NULL)
     {
         
         LinkNode*cur1=head1;
         LinkNode*cur2=head2;
       while(cur1->next!=NULL)
       {
           cur1=cur1->next;
           count1++;
       }
       
       while(cur2->next!=NULL)
       {
          cur2=cur2->next;
          count2++;
       }
         if(cur1==cur2)
         {
               printf("The two linkedlist is intersect.");
               //to find the intersect point.
             if(count1>count2)
             {
                 size_t offset=count1-count2;
                 LinkNode*fore=head1;
                 LinkNode*after=head2;
                 for(offset;offset>0;offset--)
                 {
                   fore=fore->next; 
                 }
                while(fore!=after)
                {
                    fore=fore->next;
                    after=after->next;

                }
                return fore;

             }else if(count1<count2){
                 
                 size_t offset=count2-count1;
                 LinkNode*fore=head2;
                 LinkNode*after=head1;
                 for(offset;offset>0;offset--)
                 {
                   fore=fore->next; 
                 }
                while(fore!=after)
                {
                    fore=fore->next;
                    after=after->next;

                }
                return fore;
             }else{

                 LinkNode*fore=head1;
                 LinkNode*after=head2;
                while(fore!=after)
                {
                    fore=fore->next;
                    after=after->next;

                }
                return fore;

             }

         }else{ 
             printf("The two linkdelist is not intersect."); 
         }


     }
     //Two linkedlist both have cycle.(two situations) 
     else if(pos1!=NULL && pos2!=NULL)
     {   
         //fisrt to find the entry point for the two cycles. 
         
         LinkNode*cur1=head1;
         LinkNode*cur2=head2;
          while(cur1!=pos1)
          {
              cur1=cur1->next;
              pos1=pos1->next;
          }  
        
           while(cur2!=pos2)
           {
               cur2=cur2->next;
               pos2=pos2->next;
           }
          //same entry point. 
           if(pos1==pos2)
           {
               printf("The two linkedlist is intersect.");
               // find the intersect point.
               LinkNode*tail=pos1;
               cur1=head1;
               cur2=head2;

             while(cur1->next!=NULL)
            {
               cur1=cur1->next;
               count1++;
            }
       
             while(cur2->next!=NULL)
             {
                 cur2=cur2->next;
                 count2++;
             }
             if(cur1==cur2)
             {
                 if(count1>count2)
                 {
                     size_t offset=count1-count2;
                     LinkNode*fore=head1;
                     LinkNode*after=head2;
                     for(offset;offset>0;offset--)
                     {
                         fore=fore->next; 
                     }
                     while(fore!=after)
                     {
                         fore=fore->next;
                         after=after->next;

                     }
                     return fore;

                 }else if(count1<count2)
                 {

                     size_t offset=count2-count1;
                     LinkNode*fore=head2;
                     LinkNode*after=head1;
                     for(offset;offset>0;offset--)
                     {
                         fore=fore->next; 
                     }
                     while(fore!=after)
                     {
                         fore=fore->next;
                         after=after->next;

                     }
                     return fore;

                 }else
                 {

                     LinkNode*fore=head1;
                     LinkNode*after=head2;
                     while(fore!=after)
                     {
                         fore=fore->next;
                         after=after->next;

                     }
                     return fore;

                 }


             }

           }
           // different entry point 
           else
           {
             cur1=pos1->next;
             while(cur1!=pos1)
             {
                if(cur1==pos2)
                {
                    //two linkedlist is intersect.
                    printf("The two linkedlist is intersect.");
                    return pos1;
                }
                cur1=cur1->next;
             }

           }
     }
     else
    {
      //  One has cycle  another don't have cycle.
     printf("The two linkedlist has no intersect.");
    } 

     return NULL;
}
int main()
{


    return;
}

Alsnoa
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言链表在笔试常考题.docx
03-22
C语言笔试面试常考题总结。 C语言笔试面试常考题总结。 C语言笔试面试常考题总结。 C语言笔试面试常考题总结。
链表经典笔试题（LeetCode刷题）
m0_62692838的博客
03-12 650
链表-LeetCode刷题
经典十二道链表笔试题！
分享C语言，linux相关知识
05-16 805
1. 删除链表中等于给定值val的所有节点 /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */ typedef struct ListNode Node; struct ListNode* removeElem...
【面试必看】链表的常见笔试题
Money、坤的博客
06-26 380
1. 合并链表链接：https://leetcode.cn/problems/merge-two-sorted-lists 2. 反转链表 3. 链表中倒数第k个节点 4. 删除链表的倒数第N个节点 5. 相交链表 6. 环形链表 7. 回文链表 8. 反转指定区间上范围的链表
链表常见笔试题
liyuuhuvnjjv的博客
02-29 97
1.在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 public ListNode deleteDuplication(ListNode pHead) { if(pHead == null){ return null; } if(...
链表高频笔试的OJ题
weixin_67596609的博客
12-02 885
一、合并两个有序链表 二、反转链表 三、分割链表 四、链表的回文结构 五、链表相交 六、环形链表 七、复制带有随机指针的复杂链表 OJ题目及解析和解题代码。通俗易懂，赶快进来看看吧！！！
C语言链表题目（附答案）.docx
08-07
大一初学C语言时的期末作业，涉及到链表的建立和功能的实现，涉及指针、函数、动态结构建立等方面的知识，初学者可以参考参考尝试尝试哟！！！
关于链表的一些面试题
07-25
题一、给定单链表，检测是否有环。题二、 给定两个单链表(head1, head2)，检测两个链表是否有交点，如果有返回第一个交点。等面试题。
C++ 笔试题面试大全（含答案）
08-30
单向链表的反转是一个经常被问到的一个面试题，也是一个非常基础的问题。比如一个链表是这样的： 1->2->3->4->5 通过反转后成为5->4->3->2->1。最容易想到的方法遍历一遍链表，利用一个辅助指针，存储遍历过程中当前...
lianbiaopaixu.rar_Vc_visual c_笔试_笔试 题_笔试题
09-23
2008软件公司笔试题：两个链表插入排序，VC编写
常见的链表面试题大汇总
09-05
常见的链表面试题大汇总： 1，创建一个链表结点 2，遍历链表中的所有结点 3，倒序打印链表 4，往链表末尾添加结点 5，往链表前端添加结点, 6，获取链表的节点数目 7，销毁链表 8，求链表中倒数第K个节点 9，反转链表 10，查找链表中间节点 11，判断链表是否有环 12，判断链表是否有环，并返回环上的节点数目
链表相关笔试题
m0_52083255的博客
11-20 939
链表面试题目删除链表给定的结点链表的反转（逆置链表）链表的中间结点链表的倒数第K个结点链表的第一个公共结点合并两个排序的链表分割链表删除链表中的重复元素II 删除链表给定的结点 leetcode:删除链表中给定的结点 链表的反转（逆置链表） leetcode:反转链表 链表的中间结点 leetcode：链表的中间结点 链表的倒数第K个结点 leetcode：链表的倒数第K个结点 链表的第一个公共结点 leetcode：链表的第一个公共结点 合并两个排序的链表 leetcode：合并两个排序的链
【链表】链表常见笔试题和面试题(C语言)
热门推荐
HongKnight的博客
06-15 1万+
本文为链表常见的笔试题和面试题，包含链表反转、判断链表是否有环、查找环形入口、查找公共结点、合并两个有序链表、查找倒数第K个结点、查找中间结点、删除有序链表重复结点
十大链表金典笔试题
qq_52655865的博客
05-07 522
目录 一，Leedcode面试题0205链表求和 二，Leedcode19删除链表的倒数第N个结点 三，Leedcode21合并两个有序链表 四，Leedcode82删除排序链表中的重复元素 五，Leedcode92反转链表 六，Leedcode141环形链表 七，Leedcode160相交链表 八，Leedcode234回文链表 九，Leetcode26原地删除数组中的重复项 十，面试题0204分割链表 十一，Leetcode206反转链表 一，Leedcode面试题020
链表的常见笔试题
weixin_46117546的博客
02-04 226
1. 请将给定数组，转换成链表 private static Node arrayToLinkedList(int[] arr) { //需要设置两个节点, 一个头节点,一个尾节点 //初始情况下两个都为空 Node head = null; Node tail = null; //通过 for each 依次把节点尾插到链表中 for(int x : arr){ Node newNode = new
力扣链表笔试题--看这一篇就够了
Word码鸭的博客
12-29 775
83.删除升序链表中重复的元素，使每个元素只出现一次 public class LeetCode83 {//存在一个按升序排列的链表，给你这个链表的头节点 head ， // 请你删除所有重复的元素，使每个元素 只出现一次 。 public ListNode deleteDuplicates(ListNode head) { ListNode dummyHead=new ListNode(101); dummyHead.next=head;
建议收藏|四大互联网经典链表笔试题
huzechen的博客
11-24 399
猫哥导读：随着大数据行业的发展，求职的道路上也会略显坎坷，公司对员工的要求也会越来越高，如果你在面试的路上没有碰壁过，只能说你太幸运了，我身边的朋友，基本上都会遇到面试失败的情况，大多数...
常考链表笔试题（一）
Nan_Feng726的博客
06-02 1027
1、删除链表中等于给定值 val 的所有节点。 示例: 输入: 1->2->6->3->4->5->6, val = 6 输出: 1->2->3->4->5 思路： 要删除链表中等于给定值的所有节点，我们可以定义一个结果链表，再结合尾插的方法来实现。 定义一个last引用，指向结果链表的最后一个节点，cur引用指向给定链表的第一个节点。遍...
C语言关于链表数组和队列的笔试题
最新发布
05-11
1. 请编写一个函数，将一个数组转化成链表，并返回链表的头指针。 ```c #include #include typedef struct Node { int data; struct Node *next; } Node; Node* array_to_linkedlist(int arr[], int size) { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值