链表LintCode题目总结（入门-简单）

最新推荐文章于 2024-09-01 09:15:21 发布
最新推荐文章于 2024-09-01 09:15:21 发布
阅读量620 收藏
点赞数
文章标签： 链表 数据结构 list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40739878/article/details/122028000
版权

单链表LintCode题目总结（入门-简单）版

链表的实现：

class ListNode {
  public:
     int val;
     ListNode *next;
     ListNode(int val) 
     {         
       this->val = val;
       this->next = NULL;
     }
  }

225·在链表中找节点（入门）

样例1

输入:  1->2->3 and value = 3
输出: 最后一个结点

样例2

输入:  1->2->3 and value = 4
输出: null

代码实现

ListNode * findNode(ListNode * head, int val) {
        // write your code here
        ListNode *find=head;
        while(find!=NULL)//循环遍历直至空指针
        {
            if(val==find->val)
            {
                return find;
            }
            else
            find=find->next;
        }
        return NULL;
    }

228 · 链表的中点（入门）

描述
找链表的中点，并返回这个节点。
样例1：

输入:  1->2->3
输出: 2	
样例解释: 返回中间节点

样例2：

输入:  1->2
输出: 1	
样例解释: 如果长度是偶数，则返回中间偏左的节点。

代码实现

ListNode * middleNode(ListNode * head) 
{
        // write your code here
        if (head == NULL) 
        return head;
        ListNode *fast=head->next;//快指针，一次遍历两个节点
        ListNode *slow=head;//慢指针，一次遍历一个节点，是我们需要返回的值
   
        while(fast!=NULL&&fast->next!=NULL)//当快指针指向空或其下一个表指向空结束循环
        {
            fast=fast->next->next;
            slow=slow->next;
        }
        return slow;
 }

466 · 链表节点计数（入门）

描述
计算链表中有多少个节点.

样例

样例  1:
	输入:  1->3->5->null
	输出: 3
	
	样例解释: 
	返回链表中结点个数，也就是链表的长度.

样例 2:
	输入:  null
	输出: 0
	
	样例解释: 
	空链表长度为0

代码实现

int countNodes(ListNode * head) {
        // write your code here
        int ans=0;//计数
        while(head!=NULL)
        {
            head=head->next;
            ans++;
        }
        return ans;
    }

483 · 链表转数组（入门）

描述
将一个链表转换为一个数组。

样例

样例 1:
输入: 1->2->3->null
输出: [1,2,3]

样例 2:
输入: 3->5->8->null
输出: [3,5,8]

代码实现

vector<int> toArrayList(ListNode * head) {
        // write your code here
        vector<int> v1;
        ListNode *find=head;
        while(find!=NULL)
        {
            v1.push_back(find->val);
            find=find->next;
        }
        return v1;
    }

35 · 翻转链表（一）（简单）

翻转一个链表

链表长度小于 100100

样例

样例 1：
输入：
链表 = 1->2->3->null
输出：
3->2->1->null

样例 2：
输入：
链表 = 1->2->3->4->null
输出：
4->3->2->1->null

代码实现

ListNode * reverse(ListNode * head) 
{
     // write your code here
       ListNode *Newhead=NULL;//记录前一个节点
       ListNode *Next=NULL;//用于标记下一个节点
       ListNode *Cur=head;//遍历和转向用
       while(Cur!=NULL)
       {
           Next=Cur->next;//记录下一个节点
           Cur->next=Newhead;//转向
           Newhead=Cur;//后移
           Cur=Next;//后移
       }
       return Newhead;
}

35反转链表
反转链表流程图

96 · 链表划分（简单）

描述
给定一个单链表和数值x，划分链表使得所有小于x的节点排在大于等于x的节点之前。你应该保留两部分内链表节点原有的相对顺序。
样例：

样例 1：
输入：
list = null
x = 0
输出：
null
解释：
空链表本身满足要求

样例 2：
输入：
list = 1->4->3->2->5->2->null
x = 3
输出：
1->2->2->4->3->5->null
解释：
要保持原有的相对顺序。

代码实现

ListNode * partition(ListNode * head, int x) {
			ListNode* phead = new ListNode(-1);//建立一个值为-1的头节点
       phead->next = head;//指向给定链表
       ListNode* pre = phead;//指向-1的节点
       ListNode* cur = phead;//指向-1的节点
       
       while(cur->next)//当cur走到最后一个节点出循环
       {
           if(cur->next->val >= x)//跟给定值比大小
           {
               cur = cur->next;//大于等于时，后移
           }
           else if(cur == pre)//当pre和cur指向同一个节点时
           {
               cur = cur->next;//后移
               pre = pre->next;//后移
           }
           else//出现小于的值时
           {
               ListNode* temp = cur->next;//记录cur的后一个节点，即记录需要处理的节点
               cur->next = temp->next;//指向后一个节点，起到删除temp的作用
               temp->next = pre->next;//temp插入到pre后的位置
               pre->next = temp;//原pre指向temp;
               pre = pre->next;//pre后移一位,即到达temp位;
           }   
       }
       return phead->next;
    }

96链表划分
链表划分图

112 · 删除排序链表中的重复元素（简单）

描述
给定一个排序链表，删除所有重复的元素，每个元素只留下一个。
样例

样例 1：

输入：
linked list = null
输出：
null
解释：
空链表返回null

样例 2：

输入：
linked list = 1->1->2->null
输出：
1->2->null
解释：
删除重复的1

样例 3：

输入：
linked list = 1->1->2->3->3->null
输出：
1->2->3->null
解释：
删除重复的1和3

代码实现

ListNode * deleteDuplicates(ListNode * head) {
        // write your code here
        ListNode *find=head;//用来遍历链表
        while(find!=NULL&&find->next!=NULL)
        {
            if(find->next->val==find->val)
            {
                ListNode *temp=find->next->next;//重复节点之后的节点
                delete find->next;//删除重复节点
                find->next=temp;//连接链表
            }
            else
            find=find->next;//后移
        }
        return head;
    }

165 · 合并两个排序链表（简单）

描述
将两个排序（升序）链表合并为一个新的升序排序链表

样例

样例 1:
	输入: list1 = null, list2 = 0->3->3->null
	输出: 0->3->3->null


样例2:
	输入:  list1 =  1->3->8->11->15->null, list2 = 2->null
	输出: 1->2->3->8->11->15->null

代码实现
这里我们使用一个递归函数来实现

  ListNode * mergeTwoLists(ListNode * l1, ListNode * l2) {
        // write your code here
        ListNode *temp;//定义一个暂时的链表
        if(l1==NULL&&l2!=NULL)//若l1空了且l2不为空,则temp链表后面项就后应该是l2
                return l2;
       if(l2==NULL&&l1!=NULL)
                return l1;
        if(l1==NULL&&l2==NULL)
            return NULL;
        if(l1->val>l2->val)//比较节点大小
        {
           temp=l2;//将小节点放入temp中
            l2->next=mergeTwoLists(l1,l2->next);//递归，放入节点的链表后移
        }
        else
        {
            temp=l1;
            l1->next=mergeTwoLists(l1->next,l2);
        }
        return temp;每递归一次就返回一次
    }

来个常规写法，思路是比较大小，然后放入新链表中。代码更好理解

 ListNode * mergeTwoLists(ListNode * l1, ListNode * l2) {
        // write your code here
        ListNode *head=new ListNode(-1);//整一个新节点，来存数据
        ListNode *cur=head;
        while(l1&&l2)//有一个链表为空就跳出循环
        {
           if(l1->val>l2->val)
           {
                cur->next=l2;
                l2=l2->next;   
           }
           else
           {
                cur->next=l1;
                l1=l1->next;  
           }
           cur=cur->next;//后移
        }
        cur->next=l1?l1:l2;//若出现有一个链表为空，将另一个链表放入cur中
        //a?b:c 当a为真时，返回b，否则返回c
        return head->next;
     }

166 · 链表倒数第n个节点（简单）

描述
找到单链表的倒数第n个节点，保证链表中节点的最少数量为n。
样例

样例 1:
	输入: list = 3->2->1->5->null, n = 2
	输出: 1

样例 2:
	输入: list  = 1->2->3->null, n = 3
	输出: 1

代码实现：
还是使用快慢指针来实现

ListNode * nthToLast(ListNode * head, int n) {
        // write your code here
        ListNode * fast=head;
        ListNode *slow=head;
        for(int i=0;i<n;i++)//让快指针往前先走n下
            {
                fast=fast->next;
            }
        while(fast!=NULL)//快慢指针一起走
        {
            fast=fast->next;
            slow=slow->next;
        }
        return slow;
    }

167 · 链表求和（简单）

描述
你有两个用链表代表的整数，其中每个节点包含一个数字。数字存储按照在原来整数中相反的顺序，使得第一个数字位于链表的开头。写出一个函数将两个整数相加，用链表形式返回和。
样例

样例 1:
输入: 7->1->6->null, 5->9->2->null
输出: 2->1->9->null	
样例解释: 617 + 295 = 912, 912 转换成链表:  2->1->9->null

样例 2:
输入:  3->1->5->null, 5->9->2->null
输出: 8->0->8->null	
样例解释: 513 + 295 = 808, 808 转换成链表: 8->0->8->null

代码实现
简单点在于，个位在前，所以只有两个问题需要解决
1.进位的处理。
2.链表可能长度不一致

ListNode * addLists(ListNode * l1, ListNode * l2) {
        // write your code here
        ListNode *head =new ListNode(-1);//一个新的节点
        ListNode *cur=head;//移动的指针
        int flag=0;//用来处理进位
        while(l1!=0||l2!=0||flag!=0)//只有当两个链表和进位均为零时，才会结束循环
        {
         		//a?b:c 当a为真时，返回b，否则返回c
            int l1val=l1!=NULL?l1->val:0;//取到数字，若链表为空，取0
            int l2val=l2!=NULL?l2->val:0;
            int sum=(l1val+l2val+flag)%10;//记录和，然后对10取余，保证为一位数字
            flag=(l1val+l2val+flag)/10;//对和除以10，保存进位
            ListNode *nextNode=new ListNode(sum);//创建新节点
            cur->next=nextNode;//放入新的节点中
            cur=cur->next;//节点后移
            if(l1!=NULL)//待处理两个节点的后移操作，因为两个链表可能长度不同，所以需要分别后移，
            			//若根据循环一起后期会导致越界
            {
                l1=l1->next!=NULL?l1->next:NULL;
            }
             if(l2!=NULL)
            {
                l2=l2->next!=NULL?l2->next:NULL;
            }
        }
        return head->next;
    }

173 · 链表插入排序（简单）

描述
用插入排序对链表排序
样例

样例 1:
	输入: 0->null
	输出: 0->null

样例 2:
	输入:  1->3->2->0->null
	输出 :0->1->2->3->null

代码实现

ListNode * insertionSortList(ListNode * head) {
        // write your code here
       ListNode *dummy=new ListNode(-1);
       while(head!=NULL)
       {
           ListNode *temp=dummy;//指向比较的数
           ListNode *next=head->next;//标记下一个需要处理的值
           while(temp->next!=NULL &&temp->next->val<head->val)//遇到大的值插入然后后移temp
           {
               temp=temp->next;
           }
           head->next=temp->next;//head指向temp中的大值
           temp->next=head;//temp指向head后面
           head=next;//head归位
       }
       return dummy->next;
    }

174 · 删除链表中倒数第n个节点（简单）

代码实现
跟之前找到链表中的倒数第n个节点类似，都是通过快慢指针来找到节点，多了一步删除操作

ListNode * removeNthFromEnd(ListNode * head, int n) {
        // write your code here
        ListNode * dummy = new ListNode(-1);
        dummy->next = head;
        ListNode *fast=dummy;
        ListNode *slow=dummy;
        if(head->next==NULL) return nullptr;
        for(int i=0;i<n;i++)
        {
            fast=fast->next;
        }
        while(fast->next!=NULL)
        {
            fast=fast->next;
            slow=slow->next;
        }
        slow->next=slow->next->next;//直接跳过倒数第n个节点
        
        return dummy->next;
    }

217 · 无序链表的重复项删除（简单）

描述
设计一种方法，从无序链表中删除重复项。

样例

样例 1：
输入：1->2->1->3->3->5->6->3->null
输出：1->2->3->5->6->null

样例 2：
输入：2->2->2->2->2->null
输出：2->null

代码实现

ListNode * removeDuplicates(ListNode * head) {
        // write your code here
    map<int, bool>mp;//定义一个map容器来存放数据，对于map容器不了解的，后面有其他人的博客链接
    if (head == NULL)
    {
        return head;
    }
    mp[head->val] = true;//用链表的数值做key值，如果存在value为true
    ListNode* tail = head;//用来保存不重复的值
    ListNode* now = head->next;
    while (now != NULL)
    {
        //用find函数来定位数据出现位置，它返回的一个迭代器，当数据出现时，它返回数据所在位置的迭代器，
        //如果map中没有要查找的数据，它返回的迭代器等于end函数返回的迭代器
        if (mp.find(now->val)==mp.end())//当出现未出现的值，满足if条件
        {
            mp[now->val] = true;//赋值
            tail->next = now;
            tail = tail->next;
        }
        now = now->next;//后移
    }
    tail->next = NULL;//尾指针赋空值
    return head;
    }

map容器介绍：C++ map用法总结（整理）
视频教程链接：map容器构造和赋值

219 · 在排序链表中插入一个节点（简单）

描述
在链表中插入一个节点。

样例
样例 1：

输入：head = 1->4->6->8->null, val = 5
输出：1->4->5->6->8->null
样例 2：

输入：head = 1->null, val = 2
输出：1->2->null

代码实现

ListNode * insertNode(ListNode * head, int val) {
        // write your code here
        ListNode *dummy=new ListNode(-1);//创建一个新的头节点
        dummy->next=head;
        ListNode *fast=dummy;
        if(head==NULL)//当目标链表为空时，返回给定值的链表
        {
            ListNode *temp=new ListNode(val);
            return temp;
        }
        while(fast->next!=NULL)
        {
            if(fast->next->val<val)//当链表节点值小于给定值时，链表指针后移
            {
                fast=fast->next;
            }
            else
            {
                ListNode *temp=new ListNode(val);//创建新节点
                ListNode *cur=fast->next;//记录当前节点的指针
                fast->next=temp;//指向新节点
                temp->next=cur;//指向保存的节点
                return dummy->next;
            }
        }
        //当链表走到末尾任然未插入节点时，在末尾插入
        ListNode *temp=new ListNode(val);
        ListNode *cur=fast->next;
        fast->next=temp;
        temp->next=cur;
        return dummy->next;
    }

294 · 简化链表（简单）

描述
给出一个字符链表，对其进行简化。
简化的过程为，保留链表的头尾节点，用数字代替掉中间的部分。
数字也要用字符链表表示。
样例

输入的字符链表用一个整型链表表示，链表的每个节点的值都是其对应的ASCII码。
原链表是 'h'->'e'->'l'->'l'->'o'->null。
简化后变为 'h'->'3'->'o'->null。//将ell这个三个字符用数字三代替
第二组样例中：
原链表是 'a'->'b'->...->'z'->null。
简化后变为 'a'->'2'->'4'->'z'->null。//将b-y的字母用数字24代替

输入1：
104->101->108->108->111->null
输出1：
104->51->111->null
输入2：
97->98->...->122->null
输出2：
97->50->52->122->null

代码实现

ListNode * simplify(ListNode * head) {
        //write your code here
        ListNode *fast=head;
        ListNode *insert=head;
        ListNode *slow=head;
        int count=-1;//计数变量
        while(fast->next)//移动链表
        {
            fast=fast->next;
            count++;
        }
         string s=to_string(count);//数字转字符
       for(int i=0;i<s.size();i++)
        {
            insert=new ListNode(s[i]);//插入字符
            slow->next=insert;//头节点指向新的字符
            slow=insert;//节点后移一位
        }
        slow->next=fast;//指向尾部节点
        return head;

372 · 在O(1)时间复杂度删除链表节点（简单）

描述
给定一个单链表中的一个等待被删除的节点(非表头或表尾)。请在在 O(1) 时间复杂度删除该链表节点。
样例

样例 1：
输入：
1->2->3->4->null
3
输出：
1->2->4->null
样例 2：
输入：
1->3->5->null
3
输出：
1->5->null

代码实现
通常情况下的删除节点是要知道被删除节点的前一个节点的，如果按照这种理解，那么这道题是无解的。
只能通过改变节点的值的方式来做了。但是，这样的话，如果要删除的节点是链表中的最后一个，那么也是无法删除的。

void deleteNode(ListNode * node) {
        // write your code here
        if(node) //先比较后跳转，链表本身就是一个递归结构。
        {
            node->val = node->next->val;//将后一个节点的值，赋给目标节点
            node->next = node->next->next;  //当前节点指向下下一个节点
        }
    }

451 · 两两交换链表中的节点（简单）

描述
给一个链表，两两交换其中的节点，然后返回交换后的链表。

样例
样例 1：

输入：1->2->3->4->null
输出：2->1->4->3->null
样例 2：

输入：5->null
输出：5->null

代码实现

ListNode * swapPairs(ListNode * head) {
        // write your code here
        ListNode *dummy=new ListNode(-1);
        ListNode *slow=head;
        ListNode *fast=dummy;
        while(slow&&slow->next)
        {
            ListNode *temp=slow->next->next;
            fast->next=slow->next;
            fast=fast->next;
            fast->next=slow;
            fast=fast->next;
            fast->next=NULL;
            slow=temp;
        }
        if(slow) 
        {
        fast->next=slow;
        }
        return dummy->next;
    }

452 · 删除链表中的元素（简单）

描述
删除链表中等于给定值 val 的所有节点。

样例
样例 1：

输入：head = 1->2->3->3->4->5->3->null, val = 3
输出：1->2->4->5->null
样例 2：

输入：head = 1->1->null, val = 1
输出：null

代码实现

ListNode * removeElements(ListNode * head, int val) {
        // write your code here
	    if(head == NULL) 
	        {
	            return NULL;
	        }
		ListNode *prev = head;
		ListNode *cur = head->next;
		while (cur != NULL) 
	    {
			if (cur->val != val)
	        {
				prev = cur;
			}
			else
	        {
				prev->next = cur->next;
				delete(cur);
			}
			cur = prev->next;
		}
		ListNode *NewHead = head;
		if (head->val == val) {
			NewHead = head->next;
			delete(head);
		}
		return NewHead;
	    }

489 · 链表化数组（简单）

描述
将一个数组变成链表

样例
例1:

输入: [1,2,3,4], 
输出: 1->2->3->4->null.
例2:

输入: [1,2], 
输出: 1->2->null.

代码实现

ListNode * toLinkedList(vector<int> &nums) {
        // write your code here
        if(nums.size()==0)
        {
            return NULL;
        }
        ListNode *dummy=new ListNode(-1);
        ListNode *pre=dummy;
        for(int i=0;i<nums.size();i++)
        {
            
            pre->next=new ListNode(nums[i]);
            pre=pre->next;
           
        }
        return dummy->next;
    }

756 · 两数相乘（简单）

描述
给出两个链表形式表示的数字,写一个函数得到这两个链表相乘乘积。

样例
样例 1:

输入：9->4->6->null,8->4->null
输出：79464
解释：946*84=79464
样例 2:

输入：3->2->1->null,1->2->null
输出：3852
解释：321*12=3852

代码实现

long long multiplyLists(ListNode * l1, ListNode * l2) {
        // write your code here
        long long s1=0;
        long long s2=0;
        //链表转int值然后相乘
        while(l1!=NULL||l2!=NULL)
        {
            if(l1!=NULL)
            {
                s1=s1*10;
                s1+=l1->val;
                l1=l1->next;
            }
            if(l2!=NULL)
            {
                s2=s2*10;
                s2+=l2->val;
                l2=l2->next;
            }
        }
        cout<<"s1: "<<s1<<" s2:"<<s2<<endl;
        long long ans=s1*s2;
        return ans;
    }

822 · 相反的顺序存储（简单）

描述
给出一个链表，并将链表的值以倒序存储到数组中。

样例
样例1

输入: 1 -> 2 -> 3 -> null
输出: [3,2,1]
样例2

输入: 4 -> 2 -> 1 -> null
输出: [1,2,4]

代码实现

 vector<int> reverseStore(ListNode * head) {
        // write your code here
        vector<int>ans;
        while(head)
        {
            ans.push_back(head->val);
            head=head->next;
        }
        reverse(ans.begin(),ans.end());
        return ans;
    }

1609 · 链表的中间结点（简单）

描述
给定一个带有头结点 head 的非空单链表，返回链表的中间结点。
如果有两个中间结点，则返回第二个中间结点。

样例
样例 1:

输入：1->2->3->4->5->null
输出：3->4->5->null
样例 2:

输入：1->2->3->4->5->6->null
输出：4->5->6->null

代码实现

 ListNode * middleNode(ListNode * head) 
 {
        // write your code here.
        ListNode *fast=head;
        ListNode *slow=head;
        while(fast != NULL && fast->next != NULL)
        {
            fast=fast->next->next;
            slow=slow->next;
        }
            return slow;
 }
byxhouhou
关注
链表基础题大全（二）
冷血之心的博客
03-12 2383
关于常见链表的操作总结二
LintCode刷题(入门篇)
热门推荐
秋名山小尼玛的博客
11-06 1万+
LintCode(入门篇)
LeetCode - 2 -Add Two Numbers
我们的征途是星辰大海
07-08 193
两个用链表代表的整数，其中每个节点包含一个数字。数字存储按照在原来整数中相反的顺序，使得第一个数字位于链表的开头。写出一个函数将两个整数相加，用链表形式返回和。
LintCode 项目教程
最新发布
gitblog_00680的博客
09-01 498
LintCode 项目教程 LintCodeLintCode Python项目地址:https://gitcode.com/gh_mirrors/li/LintCode 1. 项目的目录结构及介绍 LintCode/ ├── C++/ │ ├── README.md │ ├── main.cpp │ ├── config.ini │ └── ... ├── Java/ │ ├...
【数据结构】链表入门基础题
weixin_72437555的博客
12-03 781
最近笔者正在准备实验室的考核，用一些时间简单刷了一些leetcode中的简单链表题，其中遇到了些许问题并通过自己的思考加以解决，现以此博客写下自己的题解并记录自己刷题的心得。如有错误，请不吝指出。为了方便读者写博客，也为了方便读者读博客，现在下方放出笔者定义的链表存储结构与用尾插法创建链表的代码链表存储结构 尾插法创建链表 二、链表的基础操作 首先在做题之前，希望读者能够仔细阅读以下的基础操作，后续笔者的例题与以下的操作息息相关思路： ①声明一个指针指向链表第一个有效节点，也就是头结点后面的第一个结点。初始
8、lintcode学习总结
chaoyuzhang的博客
06-22 662
# -*- coding: utf-8 -*- """ Created on Fri Jun 22 11:28:01 2018 @author: zhangchaoyu """ """ 1. A + B Problem Write a function that add two numbers A and B. Example Given a=1 and b=2 return 3....
lintcode做题总结, Oct 31 A
sdadssa1的专栏
11-01 429
1. Different Ways to Add Parentheses 所有不同加括号的可能性，这种题应该可以直接想到递归 public class Solution { private int compute(String s) { //System.out.println(s); for (int i = 1; i < s
LintCode算法刷题记录（入门 + 简单部分）
SdWangTy的博客
01-03 1754
由于是初学者，实现的方法都很简单，暂时不考虑效率，之后会更新 A+B问题 给出两个整数 aa 和 bb , 求他们的和。 样例 如果 a=1 并且 b=2，返回3。 挑战 显然你可以直接 return a + b，但是你是否可以挑战一下不这样做？（不使用++等算数运算符） 说明 a和b都是 32位 整数么？ 是的 我可以使用位运算符么？ 当然可以 注意事项 你不需要从输入流读入数据，只需要根据...
leetcode-jian-zhi-offer:剑指Offer50题视频讲解
06-29
道常见的程序员面试题，这些题目偏向中低难度，是入门上手不错的选择。另外这些题目基本上在各大 OJ 上也都有，可以非常方便地提交自己的实现进行练手。 如果刚开始练习算法题目，「剑指 Offer」是个不错的切入点。...
算法竞赛入门经典经典例题及习题题解
Utopiabuntu的博客
03-10 3345
Github仓库 有些例题没找到完全相同的题目，找了类似的。 文章目录算法竞赛入门经典第一版第5章 基础题目选解5.1 字符串5.2 高精度计算5.3 排序与检索5.4 数学基础第六章 数据结构基础6.1 栈和队列6.2 链表6.3 二叉树6.4 图第七章 暴力求解法7.1 简单枚举7.2 枚举排列7.3 子集生成7.4 回溯法7.5 隐式树的遍历第八章 高效算法设计8.1 算法初步分析8.2 再...
leetcode中国-Leetcode-From-Zero:从零开始学习Leetcode。分类教程，实用技巧，推荐问题
06-29
leetcode中国 大赫的算法宝典 ...入门题目 │ │ ├─03.进阶题目 │ │ └─picture │ ├─第2章.链表(LinkedList) │ ├─第3章.二叉树(BinaryTree) │ │ ├─01.算法总结 │ │ ├─02.入门题目 │ │ └─
lintcode
02-21
lintcode
lintcode做题总结, Oct 07
sdadssa1的专栏
10-08 407
1. Scramble String 这道题代码没几行但是用了三维DP还是很复杂的，用[i][j][k]代表从s1.charAt(i)和s2.charAt(j)开始的k的字符的字符串是不是scramble，由于字符变换是基于交换的，所以只要找到那个分界线然后交换判断既可以。 public class Solution { public boolean isScramble(Str
【玩转链表②】单链表经典入门题（附方法总结于思路引领）
罅隙的博客
03-21 1110
全网最细致的单链表刷题教程，注重方法总结和思路引领。
链表相关面试题（基础篇）
agate_zhang的博客
07-24 673
链表相关面试题（基础篇）     链表是一种常见的基础数据结构，是一种线性表，是一种物理存储单元上非连续、非顺序的存储结构。链表由一系列节点组成，节点可以在运行时动态生成。每个节点包括存储数据元素的数据域和存储下一个节点地址的指针域两个部分。相比于线性表顺序结构，操作复杂。数据元素的逻辑顺序也是通过链表中的指针链接次序实现的。     线性表的链式存储特点是用一组任意的存储单元存储线性
编程题——链表
洞玄之境的博客
06-30 2542
题目： 输入一个链表，从尾到头打印链表每个节点的值。 输入一个链表，输出该链表中倒数第k个结点。 输入一个链表，反转链表后，输出新链表的表头。 输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。 复杂链表的复制：输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。...
链表c语言代码题库排坐标,C语言讲义——链表完整代码
weixin_33231849的博客
05-16 139
#include #include #include struct Node {int _id;char s[50];struct Node* pre;// 指向前一个节点的地址struct Node* next;// 指向下一个节点的地址};void node_free(struct Node** q) {if( *q != NULL) {printf("free %d\n",(*q)->...
链表相关题目及代码
weixin_53175146的博客
07-25 435
内容主要涉及到链表的相关题目
LintCode
EmoC的博客
06-30 446
两个字符串是变位词 比较字符串两个字符串是变位词import java.util.Arrays; public class Solution { /** * @param s: The first string * @param b: The second string * @return true or false */ public boo
链表基础与编程实践-C语言
3. **带头结点编程实例**：在实际编程中，常常会在链表的开始添加一个头结点，即使链表为空或者只有一个元素，处理起来也更加简单。头结点的数据域通常不存储有效数据，但可以用来存放链表的状态信息或其他辅助信息...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值