力扣面试题——链表与栈部分

最新推荐文章于 2024-03-31 21:43:39 发布
最新推荐文章于 2024-03-31 21:43:39 发布
阅读量171 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39527730/article/details/109473679
版权

找出数组中重复的数字。


在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

void Swap(int*a,int*b)
{
int c=*a;
*a=*b;
*b=c;
}
//利用快速排序
// //单趟排序   左右指针法
// int PartSort(int *a,int begin,int end)
// {
//     int key=a[end];
//     int tmp=end;
//     while(begin<end){
//         while(begin<end&&a[begin]<=key)
//             begin++;
//         while(begin<end&&a[end]>=key)
//             end--;
//        Swap(&a[begin],&a[end]);
//     }   
//     Swap(&a[begin],&a[tmp]);
//     return begin;
// }
// //单趟排序 挖坑法
// int PartSort(int *a,int begin,int end)
// {
//     int key=a[end];//坑
//     while(begin<end)
//     {
//         while(begin<end&&a[begin]<=key)//右边找大
//         begin++;
//         a[end]=a[begin];//找到打的扔到右边的坑里去，同时begin形成新的坑位
//         while(begin<end&&a[end]>=key)//左边找小
//         end--;
//         a[begin]=a[end];//找到小的扔到左边的坑位中去，同时end形成新的坑
//     }
//         a[begin]=key;
//         return begin;
// }
// //单趟排序 前后指针法
// int PartSort(int *a,int begin,int end)
// {
// //设定 cur end 与prev    
// //cur指向开始，prev指向开始的前一个数字。end指向最后一个数字！
// //cur向后移动，遇到大于end位置的数字，prev++。当cur=prev不做反应。否则狡猾cur位置与prev位置的数字
// //当cur==end；++prev 交换prev位置与end位置的数字
//     int cur=begin;
//     int key=a[end];
//     int prev=begin-1;
//     while(cur<end){
//         if(a[cur]>key&&++prev!=cur)//当第一个条件为假的时候便不会执行第二个条件，prev也就不会++；
//             Swap(&a[prev],&a[cur]);
//         ++cur;
//     }
//     ++prev;
//     Swap(&a[prev],&a[end]);
//     return  prev;
// }
// void QuickSort(int *a,int begin,int end)
// {
//     if(begin>=end)
//         return;
//     int keyindex=PartSort(a,begin,end);
//     QuickSort(a,begin,keyindex-1);
//     QuickSort(a,keyindex+1,end);
// }


int findRepeatNumber(int* nums, int numsSize){
//   //进行直接插入排序
//   //而后比较连续的数字即可
//哈希排序
    int gap=numsSize;
    while(gap>1){
        gap=gap/3+1;
    for(int i=0;i<numsSize-gap;i++)
    {
        int end=i;
        int tmp=nums[end+gap];
        while(end>=0){
            if(nums[end]>tmp){
                nums[end+gap]=nums[end];
                end-=gap;
            }
            else
            break;
        }
    nums[end+gap]=tmp;
    }
}
    // //选择排序
    // int begin=0;
    // int end=numsSize-1;
    // while(begin<end)
    // {
    //     int mini=begin;
    //     int maxi=end;
    //     for(int i=0;i<=end;i++){
    //         if(nums[i]<nums[mini])
    //             mini=i;
    //         if(nums[i]>nums[maxi])
    //             maxi=i;
    //     }
    //     Swap(&nums[begin],&nums[mini]);
    //     if(begin==maxi)
    //         maxi=mini;
    //     Swap(&nums[end],&nums[maxi]);
    //     begin++;
    //     end--;
    // }
    // //冒泡排序
    // for(int end=numsSize-1;end>0;end--){
    //     for(int i=0;i<end;i++){
    //         if(nums[i]>nums[i+1])
    //             swap(&nums[i],&nums[i+1]);
    //     }
    // }
  
  //  QuickSort(nums,0,numsSize-1);
    for(int i=0;i<numsSize;i++)
    {
        if(nums[i]==nums[i+1])
            return nums[i];
    }
    return -1;
}

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

class Solution {
public:
    string replaceSpace(string s) {
       string linjia;
       for(auto c:s)
       {
           if(c==' ')
           {
               linjia.push_back('%');
               linjia.push_back('2');
               linjia.push_back('0');
           }
           else
           {
               linjia.push_back(c);
           }
       }
       return linjia;
}
};

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
    vector<int>res;
    for(ListNode* i=head;i!=NULL;i=i->next)
        res.push_back(i->val);
    reverse(res.begin(),res.end());
   return res;
   }
};
//         vector<int>res;
//         if(head==NULL){
//         res.push_back(NULL);
//         return res;}
//         else if(head->next==NULL){
//         res.push_back(head->val);
//         return  res;}
//         ListNode *p1=head,*p2=NULL,*p3=p1->next;
//         while(p1){
//         p1->next=p2;
//         p2=p1;
//         p1=p3;
//         if(p3)
//         p3=p3->next;
//         }
//         while(p2){
//             res.push_back(p2->val);
//             p2=p2->next;
//         }
//         return res;
//     }
// };

用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

class CQueue {
public:
    stack<int>a;
    stack<int>b;
    CQueue() {

    }
    
    void appendTail(int value) {
        a.push(value);
    }
    
    int deleteHead() {
        if(a.empty()&&b.empty())
        return -1;
        if(b.empty()&&!a.empty())
        {
            while(!a.empty())
            {
                b.push(a.top());
                a.pop();
            }
        }
        int cur=b.top();
        b.pop();
        return cur;
    }
};

/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue* obj = new CQueue();
 * obj->appendTail(value);
 * int param_2 = obj->deleteHead();
 */

给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。

返回删除后的链表的头节点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* deleteNode(struct ListNode* head, int val){
    struct ListNode* cur=head->next;
    struct ListNode* prev=head;
    if(head==NULL)
    return;
    if(head->next==NULL)
    return;
    if(head->val==val)
        return head->next;
    else{
        while(cur->val!=val){
            cur=cur->next;
            prev=prev->next;
        }
        prev->next=cur->next;
        return head;
    }
   
    // while(cur){
    //     if(cur->val==val)
    //     break;
    //     prev=cur;
    //     cur=cur->next;
    // }
    // if(cur==head){//处理删除节点在头部的情况
    //     head=cur->next;
    // }
    // if(cur->next==NULL){//处理删除节点在尾部的情况
    // prev->next=NULL;
    // }
    // else{
    // prev->next=cur->next;
    // }
    // return head;
}

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

typedef struct ListNode Node;
struct ListNode* getKthFromEnd(struct ListNode* head, int k){
    if(head==NULL||head->next==NULL)
    {
        return head;
    }
    Node *cur=head;
    Node *prev=NULL;
    Node *p=cur->next;
    while(cur)
    {
        cur->next=prev;
        prev=cur;
        cur=p;
        if(p)
        p=p->next;
    }
    Node *r=prev;
    while(k-1){
        prev=prev->next; 
        k--;
    }
    prev->next=NULL;
    Node *p1=r;
    Node *p2=NULL;
    Node *p3=r->next;
    while(p1)
    {
        p1->next=p2;
        p2=p1;
        p1=p3;
        if(p3)
        p3=p3->next;
    }
    return p2;
}

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* reverseList(struct ListNode* head){
    if(head==0||head->next==0)
    return head;
    struct ListNode*prev=NULL;
    struct ListNode *cur=head;
    struct ListNode *p=cur->next;
    while(cur){
        cur->next=prev;
        prev=cur;
        cur=p;
        if(p)
        p=p->next;
    }
    return prev;
}

输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2){
    struct ListNode* head=NULL;
    struct ListNode* lite=NULL;
    if(l1==NULL)//开始就判空
    return l2;
    if(l2==NULL)
    return l1;
    while(l1&&l2)
    {
        if(l1->val<l2->val)
        {
            if(lite==NULL)
            {
                head=lite=l1;
            }
            else{
            lite->next=l1;
            lite=l1;
            }
            l1=l1->next;
        }
        else
        {
            if(lite==NULL)
            {
                head=lite=l2;
            }
            else{
            lite->next=l2;
            lite=l2;
            }
            l2=l2->next;
        }
    }
    if(l1)
    {
        lite->next=l1;
    }
    else if(l2)
    {
        lite->next=l2;
    }
    return head;
}

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

class MinStack {
public:
    stack<int>a;
    stack<int>b;//这是一个辅助栈
    /** initialize your data structure here. */
    MinStack() {

    }
    
    void push(int x) {
        a.push(x);
        if(b.empty()||b.top()>=x)
        b.push(x);
    }
    
    void pop() {
        if(a.top()==b.top())
        b.pop();
        a.pop();
    }
    
    int top() {
        return a.top();
    }
    
    int min() {
        return b.top();
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(x);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->min();
 */

输入两个链表，找出它们的第一个公共节点。

/**
 * 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) {
        if(headA==NULL||headB==NULL)
        return NULL;
        ListNode* cur=headA;
        ListNode* pur=headB;
        while(cur!=pur)
        {
            cur=cur==NULL?headB:cur->next;
            pur=pur==NULL?headA:pur->next;
        }
        return cur;
    }
};

 

dandan_healthy
关注
Python实现合并有序列表
学习使你进步。
06-02 788
本文介绍了两种Python实现合并两个有序列表的方法，分别是使用内置函数sorted()和加号运算符以及使用双指针。在Python中，我们经常需要对列表进行操作，其中，对两个有序的列表进行合并是一个常见的需求。合并后的新列表也应该是有序的，本文将介绍如何使用Python实现这一功能。比较简单的方法是将两个列表合并，然后使用Python的内置函数sorted()对其进行排序。比较i和j位置上的元素大小，将较小的那个放入新的列表，并向前移动指针。输出结果为：[1, 2, 3, 4, 5, 6, 7, 8]
Python合并两个有序列表
HackQuestR的博客
09-06 460
在Python编程中，有时候我们需要将两个有序列表合并成一个有序列表。幸运的是，Python提供了一种简单而有效的方法来实现这一目标。在本文中，我将向您展示如何使用Python合并两个有序列表，并提供相应的源代码。通过这种简单而直接的方法，我们可以轻松地合并两个有序列表并得到一个新的有序列表。的函数，它接受两个有序列表作为参数。运行代码后，我们将得到合并后的有序列表。我们的目标是将这两个列表合并为一个有序列表。我们假设我们有两个有序的列表，分别为。在给定的示例中，我们有两个有序列表。循环来处理剩余的元素。
python 列表合并 仍然有序_Python合并有序列表的输出
weixin_30396323的博客
01-13 316
我有三个列表，我们把它们叫做列表1、列表2和列表3。在列表1和2被函数作为参数接收，而列表3是在函数中创建的。在我试图获取List1并计算它中每个唯一元素出现的次数，然后将这些数字显示在仅包含这些唯一元素的列表旁边，而不包含重复项，其顺序与该元素的第一个实例在List1中出现的顺序相同。在故障：列表1包含许多元素，其中有些元素是重复的。List2包含一组来自List1的元素，其顺序与它们在List...
python合并两个有序列表_Python实现合并两个有序链表的方法示例
weixin_39997664的博客
12-03 187
本文实例讲述了Python实现合并两个有序链表的方法。分享给大家供大家参考，具体如下：思路：先选出第一个节点，然后遍历两个链表，把小的作为当前节点的下一个节点，一直到其中一个链表遍历完，这时候把另一个链表直接接上就好# Definition for singly-linked list.# class ListNode(object):# def __init__(self, x):# ...
Python--合并两个有序列表
Co_zy的博客
09-08 3524
#!/usr/bin/python # -*- coding: utf-8 -*- list1 = [3, 7, 8, 9, 12] list2 = [5, 6, 10, 13, 25, 30] result = []while list1 and list2: if list1[0] < list2[0]: result.append(list1[0]) l
力扣面试经典150题力扣面试经典150题
11-21
"力扣面试经典150题"是一系列精选的题目，旨在帮助面试者熟悉常见的面试问题，提升解决问题的能力。 在LeetCode中，面试经典150题主要分为以下几个类别： 1. **数组**：数组是最基础的数据结构，涉及到的问题包括...
【力扣面试经典150题】（链表）K 个一组翻转链表
✎ℳ๓₯㎕...雲淡風輕
11-19 568
力扣面试经典必刷题之链表
程序员面试金典 – 面试题 02.05. 链表求和
12-22
1. 题目 给定两个用链表表示的整数，每个节点包含一个数位。 这些数位是反向存放的，也就是个位排在链表首部。 编写函数对这两个整数求和，...来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/sum-list
《数据结构》十道链表经典面试题多种方法深度解析
m0_62171658的博客
03-20 6822
《数据结构》十道链表经典面试题多种方法深度解析，配有图解深度挖掘各种细节问题，打好根基，为冲击金丹期做准备。
力扣高频|算法面试题汇总(十）：图论
qq_24739717的博客
05-31 2155
力扣高频|算法面试题汇总(十）：图论 力扣链接 目录： 1.单词接龙 1.单词接龙 给定两个单词（beginWord 和 endWord）和一个字典，找到从 beginWord 到 endWord 的最短转换序列的长度。转换需遵循如下规则： 每次转换只能改变一个字母。 转换过程中的中间单词必须是字典中的单词。 说明: 如果不存在这样的转换序列，返回 0。 所有单词具有相同的长度。 所有单词只由小写字母组成。 字典中不存在重复的单词。 你可以假设 beginWord 和 endWord 是非空的，且二者
Python实现的合并两个有序数组算法示例
09-19
主要介绍了Python实现的合并两个有序数组算法,涉及Python针对数组的遍历、计算、追加等相关操作技巧,需要的朋友可以参考下
python实现合并两个有序列表
weixin_42153985的博客
06-05 5243
def hebing(list1,list2): result=[] while list1 and list2: if list1[0]&lt;list2[0]: result.append(list1[0]) del list1[0] else: result.append(...
Python - 有序列表的合并
⚡
06-06 1754
将b列表与a列表数据逐个进行比较后添加进a列表并返回（a,b有序） a = [1,3,5] b = [2,4,10,12,14,18,20] def x(a,b): #index为指向a的"指针" index = 0 for i in range(len(b)): while(index<len(a)): if b[i]&...
Python : 算法-合并两个有序列表
weixin_44523387的博客
06-09 623
def loop_merge_sort(l1, l2): tmp = [] while len(l1) > 0 and len(l2) > 0: if l1[0] < l2[0]: tmp.append(l1[0]) del l1[0] else: tmp.append(l2[0]) del l2[0] tmp.extend(l1) tmp.extend(l2) return t...
合并两个已经有序的列表python
iin729的博客
05-27 2716
输入：list1=[1,5,7,19,75]     list2=[5,7,6,9,64,186,879]输出：[1, 5, 5, 7, 7, 7, 9, 19, 64, 75, 186, 879]def sortTwoSortedList(list1=[],list2=[]): """ :param list1: 有序list,升序 :param list2: 有序lis...
列表的合并与排序（Python）
2301_79497461的博客
11-28 1844
描述‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬ 读入两行，两行的格式一样，都是用空格分隔的若干个整数，将这些数合并到一个列表中，降序排列后输出整个列表。 提示： list1 = list(map(int,input().split())) #读入一行由空格分隔的整数，将其存入list1列表中
Python(有序吗?)(合并两个有序列表)
最新发布
weixin_73729058的博客
03-31 443
那么为什么在代码中“list1 = input("list1: ").split()”不写成“list1 = [input("list1：")]”呢，但是这样直接获取一个包含用户输入的整数列表，如果用户输入 "1 2 3"，那代码生成的是一个包含单个整数 "1" 的列表。先遍历一个arr啊，这是一个外层循环，然后再写一个内层循环来比较元素，在外层循环的元素如果大于内层循环的元素，就插入。函数接收一个列表作为参数，并返回一个集合，其中包含了列表中的所有不重复元素。针对所有的元素重复以上的步骤，除了最后一个。
Python实现两个有序列表合并并排序
weixin_44585974的博客
11-17 681
方法1(稍微比较复杂) # 例如给出lis1和lis2 lis1 = [3,7,8,9,12] lis2 = [5,6,10,13,25,30] result = [] while(len(lis1) > 0 and len(lis2) > 0): if(lis1[0] < lis2[0]): result.append(lis1[0]) del lis1[0] else: result.append(lis2[0])
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值