C语言实现链表及链表常见面试题

最新推荐文章于 2024-07-24 15:28:00 发布
最新推荐文章于 2024-07-24 15:28:00 发布
阅读量269 收藏
点赞数 1
分类专栏： 数据结构&算法 文章标签： 单链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/The_shy/article/details/112238234
版权

List.h

#ifndef List_h
#define List_h
struct ListNode
{
    int data;
    struct ListNode* pNext;
};

void InitList(struct ListNode** pHead); //初始化
struct ListNode* CreateNode(int data);//创建结点
void PushBack(struct ListNode** pHead, int data);//尾插
void PopBack(struct ListNode** pHead);//尾删
void PushFront(struct ListNode** pHead, int data);//头插
void PopFront(struct ListNode** pHead);//头删
struct ListNode* Find(struct ListNode* pHead, int data);//查找数据data
void Erase(struct ListNode** pHead, struct ListNode* pos);//删除pos位置节点
void Insert(struct ListNode** pHead, struct ListNode* pos, int data);//在pos位置插入节点data
void DestroyList(struct ListNode** pHead);//删除链表
void PrintList(struct ListNode* pHead);//打印链表

void PrintListTailToHead(struct ListNode* pHead);//从尾到头打印单链表
void InsertNotHead(struct ListNode* pos, int data);//在非头节点插入数据data
void DelNotTailNode(struct ListNode* pos);//删除不是尾节点的节点
struct ListNode* FindMidNode(struct ListNode* pHead);//查找中间节点
struct ListNode* JosephCircle(struct ListNode* pHead, int M);//约瑟夫环
void ReverseList(struct ListNode** pHead);//反转单链表
void SortList(struct ListNode* pHead);//排序单链表
struct ListNode* FindLastKNode(struct ListNode* pHead, int K);//查找倒数第K个节点
int GetCyleLen(struct ListNode* pMeetNode);//获得环长度
struct ListNode* HasCycle(struct ListNode* pHead);//判断链表是否有环
struct ListNode* MergeList(struct ListNode* pL1, struct ListNode* pL2);//合并两个单链表
struct ListNode* FindEnterNode(struct ListNode* pHead, struct ListNode* pMeetNode);//
int IsListCrose(struct ListNode* pL1, struct ListNode* pL2);//判断两个链表是否相交
int IsListCroseWithCycle(struct ListNode* pL1, struct ListNode* pL2);//判断两个链表是否环内相交

#endif /* List_h */

List.c

#include "List.h"

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

void InitList(struct ListNode** pHead)//初始化
{
    *pHead = NULL;
}

struct ListNode* CreateNode(int data)//创建结点
{
    struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
    if (node == NULL) {
        return NULL;
    }
    node->data = data;
    node->pNext = NULL;
    return node;
}

void PushBack(struct ListNode** pHead, int data)//尾插
{
    assert(pHead != NULL);
    if (*pHead == NULL) {
        *pHead = CreateNode(data);
        return;
    }
    struct ListNode* node = *pHead;
    while (node->pNext) {
        node = node->pNext;
    }
    node->pNext = CreateNode(data);
}

void PopBack(struct ListNode** pHead)//尾删
{
    assert(pHead != NULL);
    if (*pHead == NULL) {
        return;
    } else if ((*pHead)->pNext == NULL) {
        free(*pHead);
        *pHead = NULL;
    } else {
        struct ListNode* pNode = *pHead;
        struct ListNode* pPreNode = NULL;
        while (pNode->pNext) {
            pPreNode = pNode;
            pNode = pNode->pNext;
        }
        pPreNode->pNext = pNode->pNext;
        free(pNode);
        pNode = NULL;
    }
}

void PushFront(struct ListNode** pHead, int data)//头插
{
    assert(pHead != NULL);
    struct ListNode* node = CreateNode(data);
    if (node != NULL) {
        node->pNext = *pHead;
        *pHead = node;
    }
}

void PopFront(struct ListNode** pHead)//头删
{
    assert(pHead != NULL);
    if (*pHead == NULL) {
        return;
    }
    struct ListNode* node = *pHead;
    *pHead = (*pHead)->pNext;
    free(node);
    node = NULL;
}

struct ListNode* Find(struct ListNode* pHead, int data)//查找数据data
{
    assert(pHead != NULL);
    struct ListNode* node = pHead;
    while (node) {
        if (node->data == data) {
            return node;
        }
        node = node->pNext;
    }
    return NULL;
}

void Erase(struct ListNode** pHead, struct ListNode* pos)//删除pos位置节点
{
    assert(pHead != NULL);
    assert(pos != NULL);
    if (*pHead == pos) {
        *pHead = pos->pNext;
        free(pos);
        pos = NULL;
        return;
    }
    struct ListNode* node = *pHead;
    while (node) {
        if (node->pNext == pos) {
            node->pNext = pos->pNext;
            free(pos);
            pos = NULL;
            return;
        }
        node = node->pNext;
    }
}

void Insert(struct ListNode** pHead, struct ListNode* pos, int data)//在pos位置插入节点data
{
    assert(pHead != NULL);
    assert(pos != NULL);
    struct ListNode* newNode = CreateNode(pos->data);
    if (newNode != NULL) {
        newNode->pNext = pos->pNext;
        pos->pNext = newNode;
        pos->data = data;
    }
}

void DestroyList(struct ListNode** pHead)//删除链表
{
    assert(pHead != NULL);
    struct ListNode* delNode = NULL;
    while (*pHead) {
        delNode = *pHead;
        *pHead = (*pHead)->pNext;
        free(delNode);
        delNode = NULL;
    }
}
void PrintList(struct ListNode* pHead)//打印链表
{
    struct ListNode* node = pHead;
    while (node != NULL) {
        printf("%d->",node->data);
        node = node->pNext;
    }
    printf("NULL\n");
}

void PrintListTailToHead(struct ListNode* pHead)//从尾到头打印单链表
{
    if (pHead != NULL) {
        PrintListTailToHead(pHead->pNext);
        printf("%d ",pHead->data);
    }
}

void InsertNotHead(struct ListNode* pos, int data)//在非头节点插入数据data
{
    assert(pos != NULL);
    struct ListNode* pNewNode = CreateNode(pos->data);
    if (pNewNode != NULL) {
        pNewNode->pNext = pos->pNext;
        pos->pNext = pNewNode;
        pos->data = data;
    }
}

void DelNotTailNode(struct ListNode* pos)//删除不是尾节点的节点
{
    assert(pos != NULL);
    assert(pos->pNext != NULL);
    struct ListNode* pDelNode = pos->pNext;
    pos->data = pos->pNext->data;
    pos->pNext = pos->pNext->pNext;
    free(pDelNode);
    pDelNode = NULL;
}

struct ListNode* FindMidNode(struct ListNode* pHead)//查找中间节点
{
    assert(pHead != NULL);
    struct ListNode* pfast = pHead;
    struct ListNode* pslow = pHead;
    while (pfast != NULL && pfast->pNext != NULL) {
        pfast = pfast->pNext->pNext;
        pslow = pslow->pNext;
    }
    return pslow;
}

/*
 *约瑟夫环：已知n个人（以编号1,2,3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，
 *数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依次规律重复下去，直到圆桌周围的人全部出列
 */
struct ListNode* JosephCircle(struct ListNode* pHead, int M)//约瑟夫环
{
    struct ListNode* pNode = pHead;
    struct ListNode* pDelNode;
    int K = M;
    if (pHead == NULL || M <= 0) {
        return NULL;
    }
    while (pNode->pNext != pNode) {
        K = M;
        while (--K) {
            pNode = pNode->pNext;
        }
        pDelNode = pNode->pNext;
        pNode->data = pDelNode->data;
        pNode->pNext = pDelNode->pNext;
        free(pDelNode);
    }
    return NULL;
}

void ReverseList(struct ListNode** pHead) //反转单链表
{
    struct ListNode* pNewNode = NULL;
    struct ListNode* pPreNode = NULL;
    struct ListNode* pNode = *pHead;
    if (*pHead == NULL || (*pHead)->pNext == NULL)
        return;
    while (pNode) {
        pPreNode = pNode;
        pNode = pNode->pNext;
        
        pPreNode->pNext = pNewNode;
        pNewNode = pPreNode;
    }
    *pHead = pNewNode;
}

void SortList(struct ListNode* pHead) //排序单链表
{
    struct ListNode* pTailNode = NULL;
    struct ListNode* pNode = NULL;
    struct ListNode* pPreNode = NULL;
    if (pHead == NULL)
        return;
    
    while(pHead != pTailNode) {
        pNode = pHead;
        while(pNode->pNext != pTailNode) {
            pPreNode = pNode;
            pNode = pNode->pNext;
            if (pPreNode->data > pNode->data) {
                int data = pPreNode->data;
                pPreNode->data = pNode->data;
                pNode->data = data;
            }
        }
        pTailNode = pNode;
    }
}

struct ListNode* FindLastKNode(struct ListNode* pHead, int K) //查找倒数第K个节点
{
    if (pHead == NULL || K <= 0)
        return NULL;
    
    struct ListNode* pFast = pHead;
    struct ListNode* pSlow = pHead;
    while (K--) {
        if(pFast == NULL)
            return NULL;
        pFast = pFast->pNext;
    }
    while (pFast) {
        pFast = pFast->pNext;
        pSlow = pSlow->pNext;
    }
    return pSlow;
}

int GetCyleLen(struct ListNode* pMeetNode) //获得环长度
{
    int iLen = 1;
    struct ListNode* pNode = pMeetNode;
    if (NULL == pMeetNode) {
        return 0;
    }
    while (pNode->pNext != pMeetNode) {
        iLen++;
        pNode = pNode->pNext;
    }
    return iLen;
}

struct ListNode* HasCycle(struct ListNode* pHead) //判断链表是否有环
{
    struct ListNode* pSlow = pHead;
    struct ListNode* pFast = pHead;
    if (pHead == NULL) {
        return NULL;
    }
    while (pFast && pFast->pNext) {
        pSlow = pSlow->pNext;
        pFast = pFast->pNext->pNext;
        if (pSlow == pFast) {
            return pSlow;
        }
    }
    return NULL;
}

struct ListNode* MergeList(struct ListNode* pL1, struct ListNode* pL2) //合并两个单链表
{
    struct ListNode* pNewHead = NULL;
    struct ListNode* pL1Node = pL1;
    struct ListNode* pL2Node = pL2;
    struct ListNode* pNode = NULL;
    struct ListNode* pTailNode = NULL;
    if (pL1 == NULL) {
        return pL2;
    }
    if (pL2 == NULL) {
        return pL1;
    }
    
    if (pL1Node->data > pL2Node->data) {
        pNode = pL2Node;
        pL2Node = pL2Node->pNext;
    } else {
        pNode = pL1Node;
        pL1Node = pL1Node->pNext;
    }
    
    pNewHead = pNode;
    pTailNode = pNode;
    while (pL1Node && pL2Node) {
        if (pL1Node->data > pL2Node->data) {
            pNode = pL2Node;
            pL2Node = pL2Node->pNext;
        } else {
            pNode = pL1Node;
            pL1Node = pL1Node->pNext;
        }
        pTailNode->pNext = pNode;
        pTailNode = pTailNode->pNext;
    }
    
    if (pL1Node == NULL) {
        pTailNode->pNext = pL2Node;
    } else {
        pTailNode->pNext = pL1Node;
    }
    return pNewHead;
}

struct ListNode* FindEnterNode(struct ListNode* pHead, struct ListNode* pMeetNode)
{
    struct ListNode* pNode1 = pHead;
    struct ListNode* pNodeM = pMeetNode;
    if (pHead == NULL || pMeetNode == NULL) {
        return NULL;
    }
    while (pNode1 != pNodeM) {
        pNode1 = pNode1->pNext;
        pNodeM = pNodeM->pNext;
    }
    return pNode1;
}

int IsListCrose(struct ListNode* pL1, struct ListNode* pL2) //判断两个链表是否相交
{
    struct ListNode* pL1Node = pL1;
    struct ListNode* pL2Node = pL2;
    if (pL1 == NULL || pL2 == NULL) {
        return 0;
    }
    while (pL1Node->pNext != NULL) {
        pL1Node = pL1Node->pNext;
    }
    while (pL2Node->pNext != NULL) {
        pL2Node = pL2Node->pNext;
    }
    if (pL1Node == pL2Node) {
        return 1;
    }
    return 0;
}

int IsListCroseWithCycle(struct ListNode* pL1, struct ListNode* pL2) //判断两个带环链表是否相交
{
    struct ListNode* pL1MeetNode = NULL;
    struct ListNode* pL2MeetNode = NULL;
    struct ListNode* pL1Node = pL1;
    struct ListNode* pL2Node = pL2;
    if (pL1 == NULL || pL2 == NULL) {
        return 0;
    }
    pL1MeetNode = HasCycle(pL1);
    pL2MeetNode = HasCycle(pL2);
    // 两个都不带环
    if (pL1MeetNode == NULL && pL2MeetNode == NULL) {
        while (pL1Node->pNext != NULL) {
            pL1Node = pL1Node->pNext;
        }
        while (pL2Node->pNext != NULL) {
            pL2Node = pL2Node->pNext;
        }
        if (pL2Node == pL1Node) {
            return 1;
        }
        return 0;
    }
    // 两个都带环
    if (pL1MeetNode != NULL && pL2MeetNode != NULL) {
        struct ListNode* pNode = pL1MeetNode;
        while (pNode->pNext != pL1MeetNode) {
            if (pL2MeetNode == pNode) {
                return 1;
            }
            pNode = pNode->pNext;
        }
        // 假如 M1 和 M2 相连，M2 在 M1 前面时，在循环内 M2 无法检测到
        if (pNode == pL2MeetNode) {
            return 1;
        }
        return 0;
    }
    return 0;
}

main.c

#include "List.h"

#include <stdio.h>
#include <stdlib.h>

void TestPushBack()
{
    struct ListNode* pHead;
    InitList(&pHead);
    PushBack(&pHead, 1);
    PushBack(&pHead, 2);
    PushBack(&pHead, 3);
    PushBack(&pHead, 4);
    PushBack(&pHead, 5);
    PushBack(&pHead, 6);
    PushBack(&pHead, 7);
    PrintList(pHead);
}
void TestPopBack()
{
    struct ListNode* pHead;
    InitList(&pHead);
    PushBack(&pHead, 1);
    PushBack(&pHead, 2);
    PushBack(&pHead, 3);
    PushBack(&pHead, 4);
    PushBack(&pHead, 5);
    PushBack(&pHead, 6);
    PushBack(&pHead, 7);
    PrintList(pHead);
    
    PopBack(&pHead);
    PopBack(&pHead);
    PrintList(pHead);
}
void TestPushFront()
{
    struct ListNode* pHead;
    InitList(&pHead);
    PushBack(&pHead, 1);
    PushBack(&pHead, 2);
    PushBack(&pHead, 3);
    PushBack(&pHead, 4);
    PushBack(&pHead, 5);
    PrintList(pHead);
    
    PushFront(&pHead,6);
    PushFront(&pHead,7);
    PushFront(&pHead,8);
    PushFront(&pHead,9);
    PrintList(pHead);
    
}
void TestPopFront()
{
    struct ListNode* pHead;
    InitList(&pHead);
    PushBack(&pHead, 1);
    PushBack(&pHead, 2);
    PushBack(&pHead, 3);
    PushBack(&pHead, 4);
    PushBack(&pHead, 5);
    PrintList(pHead);
    
    PopFront(&pHead);
    PopFront(&pHead);
    PrintList(pHead);
}
void TestFind()
{
    struct ListNode* pHead;
    InitList(&pHead);
    PushBack(&pHead, 1);
    PushBack(&pHead, 2);
    PushBack(&pHead, 3);
    PushBack(&pHead, 4);
    PushBack(&pHead, 5);
    PrintList(pHead);
    
    struct ListNode* findNode = Find(pHead, 6);
    if (findNode != NULL) {
        printf("findNode address %p,data %d\n",findNode,findNode->data);
    } else {
        printf("not find!\n");
    }
    
}
void TestErase()
{
    struct ListNode* pHead;
    InitList(&pHead);
    PushBack(&pHead, 1);
    PushBack(&pHead, 2);
    PushBack(&pHead, 3);
    PushBack(&pHead, 4);
    PushBack(&pHead, 5);
    PrintList(pHead);
    struct ListNode* findNode = Find(pHead, 1);
    Erase(&pHead, findNode);
    PrintList(pHead);
}
void TestInsert()
{
    struct ListNode* pHead;
    InitList(&pHead);
    PushBack(&pHead, 1);
    PushBack(&pHead, 2);
    PushBack(&pHead, 3);
    PushBack(&pHead, 4);
    PushBack(&pHead, 5);
    PrintList(pHead);
    struct ListNode* findNode = Find(pHead, 2);
    
    Insert(&pHead, findNode, 6);
    PrintList(pHead);
}
void TestDestroyList()
{
    struct ListNode* pHead;
    InitList(&pHead);
    PushBack(&pHead, 1);
    PushBack(&pHead, 2);
    PushBack(&pHead, 3);
    PushBack(&pHead, 4);
    PushBack(&pHead, 5);
    PrintList(pHead);
    
    DestroyList(&pHead);
    PrintList(pHead);
}
void TestPrintListTailToHead()
{
    struct ListNode* pHead;
    InitList(&pHead);
    PushBack(&pHead, 1);
    PushBack(&pHead, 2);
    PushBack(&pHead, 3);
    PushBack(&pHead, 4);
    PushBack(&pHead, 5);
    PrintList(pHead);
    PrintListTailToHead(pHead);
}
void TestInsertNotHead()
{
    struct ListNode* pHead;
    InitList(&pHead);
    PushBack(&pHead, 1);
    PushBack(&pHead, 2);
    PushBack(&pHead, 3);
    PushBack(&pHead, 4);
    PushBack(&pHead, 5);
    PrintList(pHead);
    struct ListNode* findNode = Find(pHead, 2);
    InsertNotHead(findNode,6);
    PrintList(pHead);
}
void TestDelNotTailNode()
{
    struct ListNode* pHead;
    InitList(&pHead);
    PushBack(&pHead, 1);
    PushBack(&pHead, 2);
    PushBack(&pHead, 3);
    PushBack(&pHead, 4);
    PushBack(&pHead, 5);
    PrintList(pHead);
    struct ListNode* findNode = Find(pHead, 2);
    DelNotTailNode(findNode);
    PrintList(pHead);
}
void TestFindMidNode()
{
    struct ListNode* pHead;
    InitList(&pHead);
    PushBack(&pHead, 1);
    PushBack(&pHead, 2);
    PushBack(&pHead, 3);
    PushBack(&pHead, 4);
    PushBack(&pHead, 5);
    struct ListNode* mid = FindMidNode(pHead);
    printf("mid data %d\n",mid->data);
    
    PushBack(&pHead, 6);
    mid = FindMidNode(pHead);
    printf("mid data %d\n",mid->data);
    
}
void TestJosephCircle()
{
    struct ListNode* pHead;
    struct ListNode* pTailNode = NULL;
    InitList(&pHead);
    PushBack(&pHead, 1);
    PushBack(&pHead, 2);
    PushBack(&pHead, 3);
    PushBack(&pHead, 4);
    PushBack(&pHead, 5);
    PushBack(&pHead, 6);
    PushBack(&pHead, 7);
    PrintList(pHead);
    pTailNode = Find(pHead, 7);
    pTailNode->pNext = pHead;
    pTailNode = JosephCircle(pHead, 2);
    free(pTailNode);
}

void TestReverseList()
{
    struct ListNode* pHead;
    InitList(&pHead);
    PushBack(&pHead, 1);
    PushBack(&pHead, 2);
    PushBack(&pHead, 3);
    PushBack(&pHead, 4);
    PushBack(&pHead, 5);
    PrintList(pHead);
    ReverseList(&pHead);
    PrintList(pHead);
}

void TestSortList()
{
    struct ListNode* pHead;
    InitList(&pHead);
    PushBack(&pHead, 6);
    PushBack(&pHead, 4);
    PushBack(&pHead, 1);
    PushBack(&pHead, 9);
    PushBack(&pHead, 2);
    PushBack(&pHead, 7);
    PushBack(&pHead, 0);
    PushBack(&pHead, 3);
    PushBack(&pHead, 5);
    PushBack(&pHead, 8);
    PrintList(pHead);
    SortList(pHead);
    PrintList(pHead);
}

void TestFindLastKNode()
{
    struct ListNode* pHead;
    InitList(&pHead);
    PushBack(&pHead, 1);
    PushBack(&pHead, 2);
    PushBack(&pHead, 3);
    PushBack(&pHead, 4);
    PushBack(&pHead, 5);
    PushBack(&pHead, 6);
    PrintList(pHead);
    struct ListNode* lastK = FindLastKNode(pHead,2);
    printf("last K = %d\n",lastK->data);
}

void TestGetCyleLen()
{
    struct ListNode* pHead;
    struct ListNode* pos1;
    struct ListNode* pos2;
    InitList(&pHead);
    PushBack(&pHead, 1);
    PushBack(&pHead, 2);
    PushBack(&pHead, 3);
    PushBack(&pHead, 4);
    PushBack(&pHead, 5);
    PushBack(&pHead, 7);
    PushBack(&pHead, 9);
    PrintList(pHead);
    /*---------构环---------*/
    pos1 = Find(pHead, 9);
    pos2 = Find(pHead, 5);
    pos1->pNext = pos2;
    /*---------------------*/
    int len = GetCyleLen(pos2);
    printf("cycle len = %d\n",len);
    
}

void TestHasCycle()
{
    struct ListNode* pHead;
    struct ListNode* pos1;
    struct ListNode* pos2;
    InitList(&pHead);
    PushBack(&pHead, 1);
    PushBack(&pHead, 2);
    PushBack(&pHead, 3);
    PushBack(&pHead, 4);
    PushBack(&pHead, 5);
    PushBack(&pHead, 6);
    PushBack(&pHead, 7);
    PushBack(&pHead, 9);
    PrintList(pHead);
    /*---------构环---------*/
    pos1 = Find(pHead, 9);
    pos2 = Find(pHead, 5);
    pos1->pNext = pos2;
    /*---------------------*/
    struct ListNode* pNode = HasCycle(pHead);
    if (pNode == NULL) {
        printf("list not cycle\n");
    } else {
        printf("list has cycle,pNode->data = %d\n",pNode->data);
    }
}

void TestMergeList()
{
    struct ListNode* pList1;
    struct ListNode* pList2;
    InitList(&pList1);
    PushBack(&pList1, 1);
    PushBack(&pList1, 3);
    PushBack(&pList1, 5);
    PushBack(&pList1, 7);
    PushBack(&pList1, 9);
    PrintList(pList1);
    
    InitList(&pList2);
    PushBack(&pList2, 2);
    PushBack(&pList2, 4);
    PushBack(&pList2, 6);
    PushBack(&pList2, 8);
    PrintList(pList2);
    struct ListNode* pList3 = MergeList(pList1, pList2);
    PrintList(pList3);
}

int main(int argc, const char * argv[])
{
    //TestPushBack();
    //TestPopBack();
    //TestPushFront();
    //TestPopFront();
    //TestFind();
    //TestErase();
    //TestInsert();
    //TestDestroyList();
    //TestPrintListTailToHead();
    //TestInsertNotHead();
    //TestDelNotTailNode();
    //TestFindMidNode();
    //TestJosephCircle();
    //TestReverseList();
    //TestSortList();
    //TestFindLastKNode();
    //TestGetCyleLen();
    //TestHasCycle();
    //TestMergeList();
    return 0;
}
little train
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言链表相关面试题.zip
03-13
C语言链表相关的面试题在软件开发领域的面试中是非常常见的，这是因为链表作为一种基本的数据结构，对于理解数据结构、算法以及内存管理等方面有着重要的作用。以下是一些关于C语言链表的面试题及其详细解释。 1. ...
C语言链表类面试题.docx
08-17
【C语言链表类面试题】涉及的知识点主要包括链表数据结构、链表操作和算法设计。链表是一种线性数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的指针。 1. **链表逆置** 链表逆置是链表操作中的...
链表常见面试题-c语言实现,单链表相关面试题（C语言实现）
weixin_31739613的博客
05-19 384
在这里给出一些关于单链表常见的面试题。一、 给定单链表，检测是否有环。1.题目分析仔细读题目发现还是有难度的，很多人刚开始会理解成就是判断一个单链表是否为循环链表，这样的理解是错的。题目的意思是指给出一条单链表，判断其中是否含有环，如“6”字型单链表就含有环。明白题目意思以后我们来说明解题思路，假设给定的单链表中有n个节点，我们可以利用两个指针fast和slow来求解问题。fast指针每次走两步，...
【初阶数据结构】——链表常见面试题剖析
m0_70980326的博客
01-09 1273
几道链表相关的经典面试题解析
链表常见面试题分析
GG_Bruse的博客
11-04 6828
接下来我们会从易到难，逐步讲解有关链表的常见面试，部分题目来自Leetcode和牛客
C语言常见面试题汇总
weixin_64302349的博客
01-08 4875
c语言面试高频知识点总结，文章中的知识点和问题都是在做一些题目的时候遇见的，在这里做了一下总结，供大家参考学习，文章会持续更新，欢迎大家一起学习。
链表常见面试题-C语言实现
IT_iverson的博客
08-03 7982
前面的博客已经介绍过了实现链表的一些相关的功能，所以在这里就不对链表多加解释说明了。 对于链表相关面试题这里解释几个有特点的题： 1.对于求查找链表的中间结点，要求只能遍历一次链表？ 方式：使用两个指针，一个快指针,一个慢指针,快指针走两步慢指针走一步，这样当快指针指向结尾空指针的时候，慢指针刚好指向中间结点。 图示： 2.查找链表倒数第K个结点要求只能遍历一次链表？ 方式：同
C语言实现链表
qq_74013365的博客
03-04 1377
链表是一种常见的数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的指针。链表的一个显著特点是，它不需要在内存中连续存储，因此可以高效地插入和删除节点。这种灵活性使得链表在许多应用中成为理想的选择，尤其是在需要动态调整数据结构大小的场景中。在链表的实现中，通常会有头节点和尾节点之分。头节点是链表的第一个节点，而尾节点是链表的最后一个节点。通过遍历链表，我们可以访问链表中存储的所有数据。链表还支持在链表头部或尾部快速添加新节点，这些操作的时间复杂度通常为O(1)。然而，链表也有一些缺点。
【链表】链表常见笔试题和面试题(C语言)
热门推荐
HongKnight的博客
06-15 1万+
本文为链表常见的笔试题和面试题，包含链表反转、判断链表是否有环、查找环形入口、查找公共结点、合并两个有序链表、查找倒数第K个结点、查找中间结点、删除有序链表重复结点
（C语言）干货满满！！！面试必备OJ题：链表篇（一）
博主qq1077644249
08-07 1104
这篇博客总结了几个比较常见的有关单链表的面试题，个人觉得题目比较好也比较经典，特地拿出来与小伙伴们分享。
10道经典链表面试题
xaiobit_hl的博客
05-18 3731
目录 1.删除链表中等于给定值val的所有节点 2.反转一个单链表 3.给定一个带有头结点head的非空单链表，返回链表的中间结点。如果有两个中间结点，则 返回第二个中间结点 4.输入一个链表，输出该链表中倒数第k个结点 5.将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所 有节点组成的 6. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的 结点之前 7. 链表的回文结构 8. 输入两个链表，找出它们.........
c语言链表笔试题,C语言常见单链表面试题（2）
weixin_42131890的博客
05-19 227
问题定义：写一个函数Merge函数，该函数有两个参数，都是递增的链表，函数的功能就是合并这两个递增的链表为一个递增的链表，Merge的返回值是新的链表。新链表由前两个链表按元素递增顺序合并而成，也就是说它不会创建新的元素。比如：这里有两个链表，分别是list1: 5->10->15list2: 2->3->20Merge函数返回一个指向新链表的指针，新链表应该是如下这样的：...
C语言链表在笔试常考题.docx
03-22
"C语言链表笔试面试常考题总结" 在C语言笔试面试中，链表是一道常考题，以下是两个常见的链表题目及其解决方案。 链表逆置 链表逆置是将链表的节点顺序逆转的过程。例如，原始链表为1->2->3->4->5，逆置后的链表...
面试题快慢链表和快慢指针
08-30
快慢链表和快慢指针是一种常见的数据结构和算法设计模式，广泛应用于各种面试题中，例如腾讯的一道面试题：如何快速找到位置长度单链表的中间节点？本文将详细介绍快慢链表和快慢指针的原理、实现和应用。 快慢链表...
c语言面试题之双指移除元素.zip
03-29
在C语言面试中，双指针技术是一种常见且重要的面试题型，它涉及到数组、链表、字符串等数据结构的处理。本题目的核心在于如何使用两个指针来有效地删除数组中的特定元素。这里我们将详细探讨双指针的概念、应用场景...
c语言（7.23）
fhgfyrsg的博客
07-23 575
【代码】c语言（7.23）
【算法与数据结构】并查集
2301_79728896的博客
07-23 336
合并和查询集合的数据结构，KruskalLCA查询的时间复杂度：小于O(log2​n)近乎O(1)
Linux嵌入式学习——数据结构——线性表的链式结构
最新发布
m0_71703182的博客
07-24 755
在链表的尾部插入一个新节点，该节点包含指定的数据data。函数返回成功或失败的状态码。
手撕数据结构02--二分搜索（附源码）
weixin_64593595的博客
07-24 343
对于二分搜索的理论与实现的知识点学习。
华为C语言面试题集：链表、字符串操作与内存搜索
"华为C语言面试题集，包含嵌入式领域的常见问题和解答，适合准备面试者复习和学习。" 在华为的C语言面试中，面试官可能会考察各种技能和知识，包括链表操作、字符串处理、内存管理等基础概念。以下是几道典型题目...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值