链表面试题总结

最新推荐文章于 2022-03-20 11:52:52 发布
最新推荐文章于 2022-03-20 11:52:52 发布
阅读量202 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据与结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/a331683772/article/details/90274224

1.移除值位val的元素

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
      if(head == NULL)
          return NULL;
        while(head != NULL && val == head->val )
            head = head->next;
        ListNode* pCur = head;
        while(pCur && pCur->next)
        {
            if(val == pCur->next->val)
                pCur->next = pCur->next->next;
            else
             pCur = pCur->next;
        }
        return head;
    }
};

2.链表的逆置

typedef struct ListNode ListNode;
struct ListNode* reverseList(struct ListNode* head){
   if(head == NULL)
       return NULL;
    ListNode* PreNode = NULL;
    ListNode* CurNode = head;
    ListNode* NexNode = NULL;
    while(1)
    {
        NexNode = CurNode->next;
        CurNode->next = pre;
        pre = CurNode;
        CurNode = NexNode;
    }
    return PreNode;

}

3.返回中间链表

class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        if(head == NULL || head->next == NULL)
            return head;
        ListNode* slow = head;
        ListNode* fast = head;
        while(fast != NULL && fast->next != NULL)
        {
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }
};

4.返回倒数第K个节点

class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        if(pListHead == NULL || k <= 0)
            return NULL;
        ListNode* Fast = pListHead;
        ListNode* Slow = pListHead;
        while(k--)
        {
             if(Fast == NULL)
                return NULL;
            Fast = Fast->next;
           
        }
        while(Fast)
        {
            Fast = Fast->next;
            Slow = Slow->next;
        }
    return Slow;
    }
};

5.将两个有序链表合并成一个有序链表

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1 == NULL)
        return l2;
        if(l2 == NULL)
        return l1;
        if(l1->val < l2->val)
        {
            l1->next = mergeTwoLists(l1->next,l2);
            return l1;
        }
        else
        {
              l2->next = mergeTwoLists(l1,l2->next);
            return l2;
        }
    }
};

6.以x为基准分开

class Partition {
public:
    ListNode* partition(ListNode* pHead, int x) {
        // write code here
   if(pHead == NULL)
            return NULL;
        ListNode* BeforeHead = NULL;
        ListNode* BeforeNode = NULL;
        ListNode* AfterHead = NULL;
        ListNode* AfterNode = NULL;
        ListNode* CurNode = pHead;
        ListNode* CurNext = pHead;
        while(CurNode)
        {
            CurNext = CurNode->next;
    
        if(CurNode->val < x)
        {
            if(BeforeHead == NULL)
            {
                BeforeHead = CurNode;
                BeforeNode = BeforeHead;
                BeforeNode->next = NULL;
                CurNode = CurNext;
                continue;
            }
           BeforeNode->next = CurNode;
            BeforeNode =  BeforeNode->next;
            BeforeNode->next = NULL;
            CurNode = CurNext;        
        }
        else
        {
             if(AfterHead == NULL)
            {
                AfterHead = CurNode;
                AfterNode = AfterHead;
                 AfterNode->next = NULL;
                CurNode = CurNext;
                 continue;
            }
           AfterNode->next = CurNode;
            AfterNode =  AfterNode->next;
               AfterNode->next = NULL;
            CurNode = CurNext;     
        }  
        }
        if(BeforeHead == NULL)
            return AfterHead;
        BeforeNode->next = AfterHead;
        return BeforeHead;
    }
};

7.删除重复节点

class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead)
    {
       if (pHead == NULL) {
			return NULL;
		}
		ListNode *preNode = NULL;
		ListNode *node = pHead;
		while (node != NULL) 
		{
			if (node->next != NULL && node->val == node->next->val)
			 {
				int value = node->val;
				while (node->next != NULL && node->next->val == value)
				 {
					node = node->next;
				 }
				if (preNode == NULL)
				 {
					pHead = node->next;
				 }
				 else
				  {
					preNode->next = node->next;
				  }
			} 
			else 
			{
				preNode = node;
			}
            node = node->next;
		}
		return pHead;
    }

};

8.回文链表

class PalindromeList {
public:
    bool chkPalindrome(ListNode* A) {
        // write code here
        if(A == NULL || A->next == NULL)
            return false;
        ListNode* Cur = A;
       int flag = Cur->val;
         Cur = Cur->next;
       while(Cur)
       {
           flag = flag ^ Cur->val;
            Cur = Cur->next;
       }
        if(flag == 0) return true;
            else return false;
    }
};

class PalindromeList {
public:
    bool chkPalindrome(ListNode* A) {
        // write code here
        if(A == NULL)
            return A;
        ListNode* Min = A;
         ListNode* Cur = A;
         ListNode* MinHead = NULL;
        while(Cur!=NULL && Cur->next!=NULL)
        {
            Cur = Cur->next->next;
            Min = Min->next;
        }
        Cur = A;
        MinHead =  Min->next;
        Min->next = NULL;
        
          ListNode* Pre = NULL;
         ListNode* Nex = NULL;
        while(MinHead)
        {
            Nex = MinHead->next;
            MinHead->next = Pre;
            Pre = MinHead;
            MinHead = Nex;
        }
        while(Pre)
        {
            if(Pre->val!=Cur->val)
                return false;
            Pre = Pre->next;
            Cur = Cur->next;
        }
        return true;
        
    }
};

9.相交链表相交点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode *pTail1 = headA;
        ListNode *pTail2 = headB;
        while(pTail1)
            pTail1=pTail1->next;
        while(pTail2)
            pTail2=pTail2->next;
        if(pTail1 != pTail2)
            return NULL;

        ListNode *pCur1 = headA;
        ListNode *pCur2 = headB;
        int size1 = GetLength(pCur1);
        int size2 = GetLength(pCur2);
        int gap = size1 - size2;
        if(gap > 0 )
        {
            while(gap--)
            pCur1=pCur1->next;
        }
        else
        {
            while(gap !=0)
            {
            pCur2=pCur2->next;
            gap++;
            }
        }
         
         while(pCur1 != pCur2)
         {
             pCur1=pCur1->next;
              pCur2=pCur2->next;
         }
         return pCur1;
        

        
    }
    int GetLength(ListNode *head)
    {
      int count = 0;
       ListNode *pCur = head;
      while(pCur)
      {
          count++;
          pCur= pCur->next;
      }
      return count;
    }
};

10 链表是否带环

class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(head == NULL || head->next == NULL)
        return false;
        ListNode* Fast = head;
        ListNode* slow = head;
        while(Fast!=NULL && Fast->next!= NULL && slow != NULL)
        {
            Fast = Fast->next->next;
            slow = slow->next;
            if(slow == Fast)
             return true;
        }
        return false;

    }
};

11.带环链表的入口

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        if(head == NULL || head->next == NULL)
        return NULL;
        ListNode* Fast = head;
        ListNode* Slow = head;
        while(Fast != NULL && Fast->next != NULL)
        {
            Fast = Fast->next->next;
            Slow = Slow->next;
            if(Fast == Slow)
            break;
        }
       if(Fast != Slow)
       return NULL;
       Slow = head;
       while(Fast != Slow)
       {
           Slow = Slow->next;
           Fast = Fast->next;
       }
        return Slow;
        
    }
};

12.复杂链表的复制

class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head == nullptr)
            return head;
        Node *node = head;
        while(node!=nullptr)
        {
            Node* copy = new Node(node->val,nullptr,nullptr);
            copy->next = node->next;
            node->next = copy;
            node= copy->next;
        }

        node = head;
        while(node != nullptr)
        {
            if(node->random != nullptr)
                node->next->random = node->random->next;
            node = node->next->next;
        }

        node = head;
        Node* pNewhead = head->next;
         Node* pNewNode = pNewhead;
        while(node!=nullptr)
        {
            node->next = node->next->next;
            if(pNewNode->next !=nullptr)
                pNewNode->next = pNewNode->next->next;
            node = node->next;
            pNewNode = pNewNode->next;
            
        }
        return pNewhead;
    }
};

输出二叉树第K大节点

 TreeNode* KthNode(TreeNode* root, int k){
           if(!root) return NULL;
           TreeNode *l=KthNode(root->left,k);
           if(cnt>=k) return l;
           cnt++;
           if(cnt==k) return  root;
           return KthNode(root->right,k);
    
    }

寻找二叉树公共节点

O(N^2)
BinaryNode * GetLastCommonAncestor(BinaryNode * root, BinaryNode * node1, BinaryNode * node2)
{
	BinaryNode * temp;
	while (node1 != NULL)
	{
		node1 = node1->_parent;c
		temp = node2;
		while (temp != NULL)
		{
			if (node1 == temp->_parent)
				return node1;
			temp = temp->_parent;
		}
	}
}

O(n)
int Hight(BinaryNode* root, BinaryNode* node)
{
	int len = 0;
	for (; node != NULL; node = node->_parent)
		len++;
 
	return len;
}
BinaryNode* GetLastCommonAncestor(BinaryNode* root, BinaryNode* node1, BinaryNode* node2)
{
 
	if (root == NULL || node1 == NULL || node2==NULL)
		return NULL;
 
	int len1 = Hight(root,node1);
	int len2 = Hight(root,node2);
	
 
	for (; len1 > len2; len1--)
		node1 = node1->_parent;
	for (; len2 > len1; len2--)
		node2 = node2->_parent;
 
	while (node1 && node2 && node1 != node2)
	{
		node1 = node1->_parent;
		node2 = node2->_parent;
	}
    
	if (node1 == node2)
		return node1;
	else
		return NULL;
}
递归
BinaryNode* GetLastCommonAncestor(BinaryNode* root, BinaryNode* node1, BinaryNode* node2)
{
	if (root == NULL || node1 == NULL || node2 == NULL)
		return NULL;
 
	if (node1 == root || node2 == root)
		return root;
 
	BinaryNode* cur = NULL;
 
	BinaryNode* left_lca = GetLastCommonAncestor(root->_left, node1, node2);
	BinaryNode* right_lca = GetLastCommonAncestor(root->_right, node1, node2);
	if (left_lca && right_lca)
		return root;
	if (left_lca == NULL)
		return right_lca;
	else
		return left_lca;
链表笔试面试题
fatshaw的专栏
05-28 1万+
<br />1.已知链表的头结点head,写一个函数把这个链表逆序<br />void List::reverse() { list_node * p = head; list_node * q = p->next; list_no
链表面试题总结 C/C++
Dev-L的博客
11-02 2343
数据结构和算法，是我们程序设计最重要的两大元素，可以说，我们的编程，都是在选择和设计合适的数据结构来存放数据，然后再用合适的算法来处理这些数据。       在面试中，最经常被提及的就是链表，因为它简单，但又因为需要对指针进行操作，凡是涉及到指针的，都需要我们具有良好的编程基础才能确保代码没有任何错误。       链表是一种动态的数据结构，因为在创建链表时，我们不需要知道链表的长度，
链表面试题目总结 全
09-05
链表是最基本的数据结构，凡是学计算机的必须的掌握的，在面试的时候经常被问到，关于链表的实现，百度一下就知道了。 在此总结一下与链表相关的练习题。题目很全，好好消化。
常见链表面试题的总结
I____KNOW的博客
05-22 520
/* 题目列表： 1. 求单链表中结点的个数 2. 将单链表反转 3. 查找单链表中的倒数第K个结点（k > 0） 4. 查找单链表的中间结点 5. 从尾到头打印单链表 6. 已知两个单链表pHead1 和pHead2 各自有序，把它们合并成一个链表依然有序 7. 判断一个单链表中是否有环 8. 判断两个单链表是否相交 9. 求两个单链表相交的第一个节点 10. 已知
链表（4）----反转链表
录事参军
12-11 1651
1、链表结构定义 typedef struct ListElement_t_ {     void *data;     struct ListElement_t_ *next; } ListElement_t; typedef struct List_t_{     int size;     int capacity;     ListEleme
链表面试题
tian_wen的专栏
11-03 908
某本书上面说了，链表这个东西，实际用的并不多，但是可以提供很好的考察面试者编程技巧和思维能力的素材。这里总结一下，见过的面试题和对应的候选解法。 题一、给定单链表，检测是否有环。 使用两个指针p1,p2从链表头开始遍历，p1每次前进一步，p2每次前进两步。如果p2到达链表尾部，说明无环，否则p1、p2必然会在某个时刻相遇(p1==p2)，从而检测到链表中有环。 http://ostermil
链表面试题总结：查找、合并、判定循环链表
链表面试题总结 链表是一种基本的数据结构，它在编程中有着广泛的应用。链表的面试题涵盖了链表的基本操作、链表的遍历、链表的排序、链表的反转等方面。在本文中，我们将对链表面试题进行总结，并提供相应的知识...
链表面试题总结（一）
热门推荐
宇哲
06-11 1万+
基于上一次写的链表，现在，我们来讨论下面这些问题。1.链表的冒泡排序 2.删除无头非尾节点 3.反转链表 4.在当前节点前插入一个数据x 5.查找链表的中间节点。 6.删除单链表的倒数第K个节点（K>1&&K<总长度）对于上面这6个问题，我们进行分析与解答。链表的代码我都已经写过博客：数据结构—单链表的实现另外，我也在我的github上有链表的代码，github链接如还有什么问题，可以发邮
《数据结构》十道链表经典面试题多种方法深度解析
m0_62171658的博客
03-20 7006
《数据结构》十道链表经典面试题多种方法深度解析，配有图解深度挖掘各种细节问题，打好根基，为冲击金丹期做准备。
常见的链表面试题大汇总
09-05
常见的链表面试题大汇总： 1，创建一个链表结点 2，遍历链表中的所有结点 3，倒序打印链表 4，往链表末尾添加结点 5，往链表前端添加结点, 6，获取链表的节点数目 7，销毁链表 8，求链表中倒数第K个节点 9，反转链表 10，查找链表中间节点 11，判断链表是否有环 12，判断链表是否有环，并返回环上的节点数目
链表面试题汇总
weixin_43688527的博客
06-18 245
从尾到头打印链表 blic ArrayList<Integer> printListFromTailToHead(ListNode listNode) { ArrayList<Integer>list=new ArrayList<>(); if(listNode==null)return list; while(listNode!=null){ list.add(0,listNode.val);
面试题链表总结
den11551的博客
10-19 224
面试题链表总结 链表定义为： struct Node { Node():next(nullptr) {}; Node(int val): value(val), next(nullptr){}; int value; node *next; } 规定错误处理方式： 如果返回值为指针，返回nullptr 如果返回值为数字，返回为 -１ O(1)删除链表中...
链表相关面试题总结大全
09-18 911
链表面试题大全：//1.删除有序链表中重复的结点，然后返回新链表的头结点 //由于要返回新链表的头结点，所以要定义一个指针，保存新链表的头结点； //然后定义三个指针，分别记录已删除重复结点的尾结点，当前结点，当前结点的上一个结点； // #include<iostream> using namespace std; #include<cassert> struct Node { int d
链表常见面试题总结
m0_57105290的博客
02-07 534
链表常见面试题总结1. 删除链表中等于给定值 **val** 的所有节点。2. 反转一个单链表。3. 给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。4. 输入一个链表，输出该链表中倒数第k个结点。5.将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。6. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前 ，且保证顺序不变。7.在一个排序的链表中，存在重复的结点，请删除
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值