LeetCode栈和队列练习

最新推荐文章于 2024-06-13 20:56:43 发布
最新推荐文章于 2024-06-13 20:56:43 发布
阅读量336 收藏
点赞数
分类专栏： 数据结构与LeetCode/牛客日志 文章标签： leetcode 算法 数据结构 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61894055/article/details/127903373
版权

文章目录

前言

之前的博客介绍的栈和队列的实现，本文将会对栈和队列的使用进行相关介绍。要学会灵活运用所学知识进行相关练习，这样对相关知识的理解和认识将会更加深刻。

1.力扣20. 有效的括号

1.题目分析

题目链接直接点击

在这里插入图片描述

这道题就可以运用栈这种结构来做，我们看到这个字符串中这个括号匹配方式是从里到外的，那么可以先将字符串的左括号给压入栈中，当字符串是右括号的时候就从栈中弹出数据进行匹配判断。

在这里插入图片描述

在这里插入图片描述
不管括号是成对出现，还是先出现左括号后出现右括号，栈都能进行相关的匹配。这一切都源于栈先进后出的存储特性，刚好和匹配判断的方式相契合。

2.代码示现

因为c语言中是不提供栈结构的，所以需要我们自己造一个栈出来。栈的实现还是比较简单的，之前就在博客中就介绍了栈的实现。

代码示例

typedef char STDataType;
typedef struct Stack
{
	STDataType* data;
	int top;		// 栈顶
	int capacity;  // 容量 
}Stack;
void StackInit(Stack* ps)//初始化
{
	assert(ps);
	ps->data = (STDataType*)malloc(sizeof(STDataType)*4);
	ps->top = 0;
	ps->capacity=4;
	return;
}

void StackPush(Stack* ps, STDataType x)//入栈
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
STDataType* tem = 
(STDataType*)realloc
(ps->data,ps->capacity*2*sizeof(STDataType));
		if (tem == NULL)
		{
			perror("StackPush:");
			exit(-1);
		}
        ps->data=tem;
		ps->capacity *= 2;
	}

	ps->data[ps->top] = x;
	ps->top++;
	return;
}


void StackPop(Stack* ps)//出栈
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}

STDataType StackTop(Stack* ps)//获取栈顶元素
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->data[ps->top - 1];
}

int StackEmpty(Stack* ps)//栈判空
{
	return ps->top == 0;
}

void StackDestroy(Stack* ps)//销毁栈
{
	assert(ps);
	free(ps->data);
	ps->data = NULL;
	ps->top = 0;
	ps->capacity = 0;
	return;
}
bool isValid(char * s){
    Stack st;
    StackInit(&st);
    while(*s)
    {
        if(*s=='('||*s=='['||*s=='{')
        {
            StackPush(&st,*s);
            s++;
        }
        else if(StackEmpty(&st))
             {   
                 StackDestroy(&st);
                 return false;
             }
        else 
         {      char c =StackTop(&st);
                 StackPop(&st);
                 if(*s==']'&&c!='[')
                 { StackDestroy(&st);
                     return false;
                 }
                 else if(*s=='}'&&c!='{')
                 {  StackDestroy(&st);
                     return false;
                 }
                 else if(*s==')'&&c!='(')
                 {   StackDestroy(&st);
                     return false;
                 }
                s++;
         }
    }
    bool ret=(bool)StackEmpty(&st);
    StackDestroy(&st);
  return ret;
}

有了栈就挨个遍历字符串，如果是字符是左括号的一种就压入栈，如果不是就将栈中数据弹出，进行匹配，注意要现获得栈顶元素匹配判断，然后再Pop。如果再字符串还没遍历完栈就空了，这说明这个字符串肯定不是符合要求的，因为出现这样的情况大致有两个可能，第一就是第一元素不是左括号，上来就是右括号，这样肯定是不符合要求的，还有一种可能，左括号比右括号少或者，或者括号位置不是按正确的位置出现的，这样都是不符合要求的，直接返回false.在返回之前一定记得调用销毁函数，不然就是内存泄漏。在else的语句中，是可以将else if合成一条语句判断的，我嫌看起来太挤了，就每种括号单独判断了。同时如果每个括号都能正确匹配上，最后栈遍历完字符串后栈一定是空的，如果栈为空就是符合要求的字符串，如果没有栈为空判断的话，还有可能字符串的左括号比右括号多的这种现象，所以要加上栈为空的判断，每次返回时一定记得提前进行栈销毁。

2.力扣225. 用队列实现栈

1.题目分析

题目链接直接点击

在这里插入图片描述

这道题是用队列实现栈，其实主要的重点在于用队列模拟实现栈出数据的方式。我们首先要搞清队列和栈的进出数据的方式。队列的是先进先出的，栈的先进后出的。所以我们可以用两个队列来回倒腾数据。先用一个队列来存储数据，要出数据时，将这个队列的前n-1个数据倒入空队列中，这样原队列只剩一个数据了，这个就当于栈中的栈顶元素。将这个数据弹出，就实现了数据出栈，这两个队列来回倒腾就可以了。

在这里插入图片描述

利用队列出数据的方式，来回倒腾就模拟了栈出数据的方式

2.代码实现

既然是用队列实现栈，所以就得有队列，所以先写好队列，然后就是调用队列的相关接口来实现栈。

代码示例

typedef int QDataType;
//定义队列节点
typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}QueueNode;
//定义队列
typedef struct Queue
{
	QueueNode* head;//维护队头
	QueueNode* tail;//维护队尾
	int sz;//记录队列元素个数
}Queue;
void QueueInit(Queue* q)//初始化队列
{
	assert(q);
	q->head = NULL;
	q->tail = NULL;
	q->sz = 0;
	return;
}

void QueuePush(Queue* q, QDataType data)//队尾入列
{
	    assert(q);
		QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
		if (newnode==NULL)
		{
			perror("QueuePush:");
			exit(-1);
		}
		newnode->data = data;
		newnode->next = NULL;
		if (q->head == NULL)
		{
			q->head = q->tail = newnode;
			
		}
		else  
		{   
			q->tail->next = newnode;
			q->tail = newnode;
			
		}
		q->sz++;
		return;
}
void QueuePop(Queue* q)//队头元素出列
{
	assert(q);
	assert(!QueueEmpty(q));
	if (q->head->next == NULL)//队列只有一个节点
	{
		free(q->head);
		q->head = NULL;
	}
	else
	{
		QueueNode* del = q->head;
		q->head = q->head->next;
		free(del);
	}
	q->sz--;
	return;
}


QDataType QueueFront(Queue* q)//获取队列队头元素
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->head->data;
}

QDataType QueueBack(Queue* q)//获取队列队尾元素
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->tail->data;
}


int QueueSize(Queue* q)//获取队列元素个数
{   
	assert(q);
	return q->sz;
}

int QueueEmpty(Queue* q)// 检测队列是否为空
{
	assert(q);
	return q->sz==0 ;
}

void QueueDestroy(Queue* q)// 销毁队列
{
	assert(q);
	QueueNode* cur = q->head;
	while (cur)
	{
		QueueNode* Next = cur->next;
		free(cur);
		cur = Next;
	}
	q->head = NULL;
	q->tail = NULL;
	q->sz = 0;
	return;
}


typedef struct {
    Queue q1;
    Queue q2;

} MyStack;


MyStack* myStackCreate() {
    MyStack* st=(MyStack*)malloc(sizeof(MyStack));
    QueueInit(&st->q1);
    QueueInit(&st->q2);
    return st;

}

void myStackPush(MyStack* obj, int x) {
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
     {
         QueuePush(&obj->q2,x);
     }

}

int myStackPop(MyStack* obj) {
    Queue* empty=&obj->q1;
    Queue* Noempty=&obj->q2;
    if(QueueEmpty(&obj->q2))
    {
        empty=&obj->q2;
        Noempty=&obj->q1;
    }
     while(QueueSize(Noempty)>1)
     {
         QueuePush(empty,QueueFront(Noempty));
         QueuePop(Noempty);
     }
   int Top=QueueFront(Noempty);
   QueuePop(Noempty);
   return Top;
}

int myStackTop(MyStack* obj) {
    if(QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q2);
    }
    else
    {
        return QueueBack(&obj->q1);
    }

}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);

}

队列有获取队头的元素的接口，所以每次倒腾到其中某个队列只有一个数据时就获取这个队头元素，相当于得到了栈顶元素，然后pop队列相当于将这个队列又重新置为空。如果队列1不是空，就往里面插入数据，如果队列1为空，就往队列2插入数据。同时队列有获取队尾元素的接口，如果想获取栈顶元素，直接通过这个接口获取不为空的队列的尾元素即可。如果两个队列都是空的，栈就为空。在实现栈pop时，可以先假设队列1为空，队列2不为空，如果不是两者交换即可。这是一个小的处理技巧之前链表题也用到过。销毁栈时，直接调用相关的接口销毁队列和表示栈的变量即可。

队列实现栈，一定要保证其中一个队列是空的，用来倒腾数据，数据时到底是哪个队列出数据，一定要搞清楚。队列实现栈，就是通过队列的接口函数来实现操作这个栈，不能直接去访问这个队列的内部。

3.力扣232. 用栈实现队列

1.题目分析

题目链接直接点击
在这里插入图片描述

这道题是用两个栈来实现队列。主要的难点也是出数据。还是先前的方式倒腾一下数据，但是倒腾的方式和之前就有所区别了。我们画图分析一下。

在这里插入图片描述

通过图我们可以看到当栈转移一部分数据到另一个栈中时，数据出栈的顺序就和队列一样了，这都源于栈先进后出的特性。所以我用一个栈来存储数据，另一个栈用来专门出数据，出数据时只用将存储数据的栈中的数据导入这个出数据的栈中即可。这个出数据的栈直接出数据，和队列出数据的顺序一样。

2.代码实现

用栈实现队列，也得先建栈。有了栈就直接调用相关的接口来实现即可。

代码示例

typedef int STDataType;
typedef struct Stack
{
	STDataType* data;
	int top;		// 栈顶
	int capacity;  // 容量 
}Stack;
int StackEmpty(Stack* ps);
void StackInit(Stack* ps)//初始化
{
	assert(ps);
	ps->data = (STDataType*)malloc(sizeof(STDataType)*4);
	ps->top = 0;
	ps->capacity=4;
	return;
}

void StackPush(Stack* ps, STDataType x)//入栈
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		STDataType* tem = 
		(STDataType*)realloc
		(ps->data, ps->capacity*2*sizeof(STDataType));
		if (tem == NULL)
		{
			perror("StackPush:");
			exit(-1);
		}
		ps->data = tem;
		ps->capacity *= 2;
	}

	ps->data[ps->top] = x;
	ps->top++;
	return;
}


void StackPop(Stack* ps)//出栈
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}

STDataType StackTop(Stack* ps)//获取栈顶元素
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->data[ps->top - 1];
}

int StackEmpty(Stack* ps)//栈判空
{
	return ps->top == 0;
}

int StackSize(Stack* ps)//获取栈中有效元素个数
{  
	assert(ps);
	return ps->top;
}
void StackDestroy(Stack* ps)//销毁栈
{
	assert(ps);
	free(ps->data);
	ps->data = NULL;
	ps->top = 0;
	ps->capacity = 0;
	return;
}


typedef struct {
    Stack stpop;
    Stack stpush;
} MyQueue;
bool myQueueEmpty(MyQueue* obj);
int myQueuePeek(MyQueue* obj);

MyQueue* myQueueCreate() {
    MyQueue* q=(MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&q->stpop);
    StackInit(&q->stpush);
    return q;
}

void myQueuePush(MyQueue* obj, int x) {
    assert(obj);
    StackPush(&obj->stpush,x);

}

int myQueuePop(MyQueue* obj) {
    assert(obj);
    assert(!myQueueEmpty(obj));
    int peek= myQueuePeek(obj);
    StackPop(&obj->stpop);
    return peek;
}

int myQueuePeek(MyQueue* obj) {
 assert(obj);
 assert(!myQueueEmpty(obj));
 if(StackEmpty(&obj->stpop))
 {
     while(!StackEmpty(&obj->stpush))
     {
         StackPush(&obj->stpop,StackTop(&obj->stpush));
         StackPop(&obj->stpush);
     }
 }
 
 return StackTop(&obj->stpop);
}

bool myQueueEmpty(MyQueue* obj) {
    assert(obj);
   return StackEmpty(&obj->stpop)&&StackEmpty(&obj->stpush);

}

void myQueueFree(MyQueue* obj) {
    assert(obj);
    StackDestroy(&obj->stpop);
    StackDestroy(&obj->stpush);
    free(obj);

}

在入数据时，直接将数据插入stpush栈中，出数据时将stpush栈顶元素依次插入stpop栈中，每次插入后，stpush栈都栈pop一下，这样导完数据后，stpush栈也会被清空。出数据时，只用将stpop栈的栈顶数据弹出，每次弹出数据时，都要栈pop一下。这个获得队头元素的接口函数，就是获得stpop栈中的栈顶元素，因为在实现这个这个函数时，已经实现了栈数据的倒入，所以我们在实现队列pop接口时，再次复用这个接口即可。但是一定要将这个接口声明定义写在队列pop函数之前，不然就会出现使用未定义符号的错误。队列判空很好判断，就是两个栈同时为空时。free接口就是调用栈销毁接口，再将malloc的队列变量给free即可。

在导入数据时一定要保证出数据的栈是空的。每次出数据的栈出完栈中所有数据后，再要出数据时，接着将数据导入出数据的栈。每次出数据就从这个栈出，这一步就是这道题的关键。

4.力扣622. 设计循环队列

1.题目分析

题目链接直接点击
在这里插入图片描述

这道题我们先搞清楚循环队列的是什么，再来分析题目。

在这里插入图片描述
在这里插入图片描述

以上图为例当队列4个空间满了后，如果队列要出数据，假如1和2从队列出去了，这个时候队列4个位置就空出来了，此时想将插入数据 5，6，这个时候再4的后面插入5即可，接着插入6。这个时候其实3相当于队头，6相当于队尾了，循环队列可以重复利用队列的空间，同时队头和队尾是在随时动态变化的，这就是一个简单的循环队列。

循环队列的实现有和普通队列的实现方式一样，都有两种方式，分别是链式实现和数组实现。这里我采用数组实现，因为这个循环队列其实不会涉及元素的挪动，队头和队尾的位置是动态变换的，只用设计两个变量记录队首和队尾的位置即可，在插入数据和删除数据时实时更新队头和队尾的位置即可。这就利用了数组可以进行随机访问的特点。但是如果使用链表的话，就略显麻烦一点。

确定了循环队列的实现方式，就先定义循环队列的结构吧。循环队列的成员大致有4个：一个是循环队列的存储空间也就是数组，还有一个整数是表示循环队列的大小，也就是可以存储多少个数据，剩余两个成员就是分别记录队尾位置和队头位置。

队列结构有了，这个队列怎么循环起来呢？我们画图分析一下吧

在这里插入图片描述

在这里插入图片描述
循环队列满了就无法插入数据，只有队列中在未满的情况下才能插入数据。虽然它的物理结构是数组，但是它的逻辑结构类似于一个环。

2.代码实现

代码示例

typedef struct {
    int *a;
    int front;
    int tail;
    int k;

} MyCircularQueue;
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a=(int*)malloc(sizeof(int)*(k+1));//多开一个空间，用于判满
    obj->k=k;
    obj->front=0;
    obj->tail=0;
    return obj;

}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    assert(obj);
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->a[obj->tail++]=value;
    obj->tail%=(obj->k+1);
    return true;

}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->front++;
    obj->front%=(obj->k+1);
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
   return obj->a[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
   assert(obj);
   if(myCircularQueueIsEmpty(obj))
   {
       return -1;
   }
  return obj->a[(obj->tail+obj->k)%(obj->k+1)];
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
   assert(obj);
   return obj->tail==obj->front;

}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->tail+1)%(obj->k+1)==obj->front;

}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}

在代码实现时还有很多的小细节需要注意，在插入数据时，每次往前走，但是需要进行操作tail=tail%(obj->k+1)，这是为了避免tail在往前走的过程中造成数组越界。有了这个取余操作，tail就可以像在圆中走一样，不断循环往复。获取队头元素就是获取front指向的数据。但是获取队尾元素还需要取余操作（tail+k)%(k+1），这是因为front指向就是队头元素，但是tail的后一个才是队尾元素，如果在队尾变更的过程中，tail指向下标0，如果不余直接就是tail-1，这明显就是不符合逻辑的，此时的队尾的下标应该是在k-1的位置处。所以需要格外注意，判空就是front==tail,判满就是（tail+1)%(k+1)==front。

5.总结

  • 本文总结了部分栈和队列的题目，在用代码实现之前一定要自己先画图梳理清楚逻辑，这些数据结构存储数据的特点一定要清楚。
  • 为了更好的熟练运用相关知识还是要对栈和队列的相关习题进行练习。
  • 以上内容如有问题，欢迎指正！
宗介@bit
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode气温-leetcode:leetcode算法练习
07-01
leetcode算法练习 最长上升子序列 重叠 不重叠 dp 贪心算法 : 贪心算法、队列 单调栈 拓扑排序 前缀和: 前缀和之间的差 动态规划 回文串 需要注意dp的计算顺序, 被依赖的dp状态需要先通过已知的状态计算出来 回溯...
acwing和leetcode-Algorithm:acwinglabuladongleetcode
07-07
acwing和leetcode 算法小结 0、排序 快速排序 快速排序 第K个数 归并排序 归并排序 逆序对的数量 1、二分 整数二分 数的范围 小数二分 数的三次方根 2、前缀和 一维前缀和 前缀和数组 二维前缀和 子矩阵的和 3、差分...
春节7天练丨Day2：栈、队列和递归1
08-03
关于栈、队列和递归的几个必知必会的代码实现队列递归对应的 LeetCode 练习题（@Smallfly 整理）英文版：https://leetcode.com/
考研数据结构和leetcode-LeetCode:力码
06-30
鉴于没有刷过题经历，对于数据结构课程一些概念，如线性表、栈和队列、树等，以前本科也上过课，读研后自己又补过一次，工作后又看了一遍，但是由于没有经历持续有效编程项目实践积累，基本这几次看完之后很快就忘记...
LeetCode判断字符串是否循环-Queue_Stack:依赖数组实现栈，实现链式队列，实现循环队列，两个栈实现一个队列，两个队列实现一个栈
07-01
3、栈的练习题之括号匹配 可以在leetcode上找到 明确，括号的几种情况 1、左右括号匹配 2、左括号多 3、右括号多 4、括号次序不匹配 步骤： 0、遍历给定字符串的每个元素 1、判断元素是否是左括号，若是左括号，则...
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 315
【代码】力扣LCP 08.剧情触发时间。
【回溯】Leetcode 77. 组合【中等】
FLGB
06-11 225
你可以按 任何顺序 返回答案。
【代码随想录训练营】【Day 41】【动态规划-1 and 2】| Leetcode 509, 70, 746, 62, 63
qq_44574200的博客
06-09 278
【代码随想录训练营】【Day 41】【动态规划-1 and 2】| Leetcode 509, 70, 746, 62, 63。
LeetCode 算法：轮转数组c++
小金牛来了
06-09 658
LeetCode 算法：轮转数组c++
leetcode387：字符串中的第一个唯一字符
Ricky_youngone的博客
06-10 176
这个题目看似简单，实际上很考验你对于字符数组的理解，说白了，这个题目中档，一开始我用的是遍历和标记，最后发现不行。换了unordered_map这个方法，这个方法也是映射，也就是遍历一遍给的字符，把单独的字符在char映射到int中增加1，然后在遍历一遍字符，看看哪个是第一个出现且char映射的int数字只有1，这个就是第一个唯一字符。
力扣78. 子集
akdjfhx的博客
06-08 308
力扣78. 子集
【代码随想录训练营】【Day 50】【动态规划-9】| Leetcode 198, 213, 337
qq_44574200的博客
06-10 420
【代码随想录训练营】【Day 50】【动态规划-9】| Leetcode 198, 213, 337。
182.二叉树：二叉搜索树的最小绝对差（力扣）
weixin_63779802的博客
06-13 207
这个算法的时间复杂度是 O(n)，因为每个节点都会被访问一次，其中 n 是树中节点的数量。空间复杂度也是 O(n)，因为需要存储递归调用的栈。
leetcode 40. 组合总和 II
smallplum123的博客
06-10 472
给你一个的整数数组candidates和一个目标整数target，找出candidates中可以使数字和为目标数target的不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。candidates中的 同一个 数字可以。如果至少一个数字的被选数量不同，则两种组合是不同的。对于给定的输入，保证和为target的不同组合数少于 150 个。
[力扣题解] 617. 合并二叉树
东皇太一在此的博客
06-07 451
递归法遍历，随便一种遍历方式都可以，以前序遍历为例；
Leetcode 3040. 相同分数的最大操作数目 II（记忆化搜索）
ooold_six的博客
06-09 212
使用memo[ n ][ n ]数组记录已经进行过的计算，memo[ l ][ r ]表示 l 和 r 区间的最大操作数，若这个区间的最大操作数已经存在，则无需再次dfs下去，直接获取memo值即可。若该区间memo不存在，则dfs后将值存入memo[ l ][ r ]每次操作给出三种选择，根据三种选择分别进行dfs。，这两种操作后的剩余区间是相同的）dfs中有大量重复操作。
leetcode够用之java语法
qq_30898861的博客
06-09 468
获取str中的第i-1个字符 去除字符串str开头和末尾的空格 substring截取字符串str.subtring（从此下标，往后要这么多个） 判断字符串某位是不是数字 ######删除字符串中的某一字符（str得是StringBuilder或StringBuffer） 把String类型转换为StringBuilder或StringBuffer 调试模式时，高亮的行，是将要执行的语句（还未执行）ctrl+shift+F8 查看程序所有断点IDEA块缩进：tabshift+tab 是一个内置的方法
leetcode415：字符串相加
最新发布
Ricky_youngone的博客
06-13 184
这个代码在重新回顾一遍吧，记得上次写这个题的时候用的是数组来写的，在官方里学到用字符串写的，值得我去记录。实际上这个代码很简答，就是模拟加法过程，从一个数字的最后一位开始往前遍历，要是当前位相加大于10，那就保留下当前的数对于10的余数，把前面的一位加上当前位除以10的结果，一直按照这个过程往前遍历，就能得到最后的结果，三目运算符是个好东西，记录一下。
每日5题Day24 - LeetCode 116 - 120
alimamaalala的博客
06-13 144
【代码】每日5题Day24 - LeetCode 116 - 120。
leetcode java刷题
08-11
例如，可以使用数组、链表、栈、队列等数据结构，以及排序、查找、动态规划等算法。 此外，LeetCode还提供了讨论区，你可以在这里查看其他人的解题思路和讨论。这些讨论对于理解问题和学习别人的优秀解法非常有帮助...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值