C语言超详细i讲解双向链表

目录
  • 一、双向链表的概念
  • 二、双向链表的实现
  • 三、链表与顺序表的差别
  • 四、链表oj
  • 总结

一、双向链表的概念

1、概念:概念:双向链表是每个结点除后继指针外还有⼀个前驱指针。双向链表也有带头结点结构和不带头结点结构两种,带头结点的双向链表更为常用;另外,双向链表也可以有循环和非循环两种结构,循环结构的双向链表更为常用。

二、双向链表的实现

头文件List.h

#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
typedef int LTDateType;
typedef struct ListNode
{
	LTDateType date;
	struct ListNode* next;
	struct ListNode* prev;
}LTNode;
//void ListInit(LTNode** pphead);
void ListPrint(LTNode* phead);
void ListPopBack(LTNode* phead);
LTNode* ListInit();//初始化
LTNode* BuyLTNode(LTDateType x);
void ListPushBack(LTNode* phead, LTDateType x);
void ListPushFront(LTNode* phead, LTDateType x);
void ListPopFront(LTNode* phead);
LTNode* ListFind(LTNode* phead, LTDateType x);
//在pos前插入
void ListInsert(LTNode* pos, LTDateType x);
//删除pos位置的节点
void ListErease(LTNode* pos);
void ListDestory(LTNode* phead);

源文件List.C

#include"List.h"
LTNode* BuyLTNode(LTDateType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->date = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}
//void ListInit(LTNode** pphead)
//{
//	assert(pphead);
//	*pphead = BuyLTNode(0);
//	(*pphead)->next = *pphead;
//	(*pphead)->prev = *pphead;
//}
LTNode* ListInit()
{
	LTNode* phead = BuyLTNode(0);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}
void ListPrint(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d ", cur->date);
		cur = cur->next;
	}
	printf("\n");
}
void ListPushBack(LTNode* phead, LTDateType x)
{
	assert(phead);
	LTNode* tail = phead->prev;
	LTNode* newnode = BuyLTNode(x);
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}
void ListPushFront(LTNode* phead, LTDateType x)
{
	assert(phead);
	ListInsert(phead->next, x);
}
void ListPopBack(LTNode* phead)//尾删
{
	assert(phead);
	assert(phead->next != phead);//说明传进来的不只有phead,不然phead被free掉了。
	//LTNode* tail = phead->prev;
	//LTNode* tailPrev = tail->prev;
	//free(tail);
	//tail = NULL;
	//tailPrev->next = phead;
	//phead->prev = tailPrev;
	ListErease(phead->prev);
}
void ListPopFront(LTNode* phead)//头删
{
	assert(phead);
	assert(phead->next != phead);
	ListErease(phead->next);
}
LTNode* ListFind(LTNode* phead, LTDateType x)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->date == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
//void ListInsert(LTNode* pos, LTDateType x)
//{
//	assert(pos);
//	LTNode* newnode = BuyLTNode(x);
//	pos->prev->next = newnode;
//	newnode->prev = pos->prev;
//
//	pos->prev = newnode;
//	newnode->next = pos;
//
//}
//更好的写法
void ListInsert(LTNode* pos, LTDateType x)
{
	assert(pos);
	//无关写的顺序
	LTNode* newnode = BuyLTNode(x);
	LTNode* posPrev = pos->prev;
	newnode->next = pos;
	pos->prev = newnode;
	posPrev->next = newnode;
	newnode->prev = posPrev;
}
// 驼峰法
//函数和类型所以单词首字母大写
//变量:第一个单词小写后续单词首字母大写
void ListErease(LTNode* pos)
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* next = pos->next;
	free(pos);
	//此时要把pos置成空,不然pos就是野指针了
	pos = NULL;
	prev->next = next;//LT的新的prev指向pos->next;
	next->prev = prev;//LT的新的next的prev指向prev;
}
void ListDestory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;//从头结点的下一个位置开始。
	while (cur != phead)
	{
		LTNode* next = cur->next;//先记录,再free
		//ListErease(cur);//副用Erease函数实现destory
		free(cur);//
		cur = next;
	}
	free(phead);
	//phead = NULL;形参的改变不影响实参
}

三、链表与顺序表的差别

不同点 顺序表 链表
存储空间上 物理上一定连续 逻辑上连续,但物理上不一定连 续
随机访问 支持O(1) 不支持:O(N)
任意位置插入或者删除元 素 可能需要搬移元素,效率低O(N) 只需修改指针指向
插入 动态顺序表,空间不够时需要扩容 没有容量的概念
应用场景 元素高效存储+频繁访问 任意位置插入和删除频繁
缓存利用率

四、链表oj

1、链表中倒数第k个结点_牛客题霸_牛客网(链接)

思路:快慢指针法,fast先走k步, slow和fast同时走, fast走到尾时,slow就是倒数第k个

代码示例:

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    struct ListNode* slow, *fast;
    slow = fast = pListHead;
    while(k --)//走k步
    {
        //判断K是否大于链表的长度。
        if(fast == NULL) return NULL;
        fast = fast->next;
    }
    while(fast)//当fast 指针走到尾时
    {
        slow = slow->next;
        fast = fast->next;
    }
    return slow;
}
第二种写法:
struct ListNode* FindKthToTail(struct ListNode* pListHead, int k )
{
    struct ListNode* p1 = NULL, *p2 = NULL;
    p1 = pListHead;
    p2 = pListHead;
    int a = k;
    int c = 0;//记录节点个数
      //p1指针先跑,并且记录节点数,当p1指针跑了k-1个节点后,p2指针开始跑,
        //当p1指针跑到最后时,p2所指指针就是倒数第k个节点
    while(p1)//当p1 不为空时
    {
        p1 = p1->next;
        c ++;//节点个数增加
        if(k < 1) p2 = p2->next;
        k --;
    }
    if(c < a) return NULL;
    return p2;
}

2、21. 合并两个有序链表(链接)

思路:归并的思想,将小的值尾插到新链表。时间复杂度为n^2;如果再定义一个尾指针, 每次记录尾。

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{
    if(list1 == NULL)//list1和list2分别是两个链表的头指针
        return list2;
    if(list2 == NULL)
        return list1;
    struct ListNode* head = NULL, *tail = NULL;//head是新链表的头指针,tail是新链表的尾指针
    while(list1 && list2)
    {
            if(list1->val < list2->val)
            {
                if(tail == NULL)//这一步不太理解
                {
                    head = tail = list1;
                }
                else
                {
                    tail->next = list1;//先传指针指向
                    tail = list1;//再把list 的地址传给tail,相当于tail往前挪了一步。
                }
                list1 = list1->next;
            }
            else
            {
                if(tail == NULL)
                {
                    head = tail = list2;
                }
                else
                {
                    tail->next = list2;
                    tail = list2;//传地址
                }
                 list2 = list2->next;
            }
    }
    if(list1)
    {
        tail->next = list1;//如果链表1不为空,而此时链表二为空,则直接把链表二的值连接过去就好了。
    }
    if(list2)
    {
        tail->next = list2;
    }
    return head;
}
//方法二:设置一个哨兵位头结点
//head存随机值, head->next存第一个链表的值。起到简化代码的作用。
//一般的链表没有设置哨兵位头结点。
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{
    struct ListNode* head = NULL, *tail = NULL;
    head = tail = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->next = NULL;
    while(list1 && list2)
    {
            if(list1->val < list2->val)
            {
                    tail->next = list1;//先传指针指向
                    tail = list1;//再把list 的地址传给tail,相当于tail往前挪了一步。
                list1 = list1->next;
            }
            else
            {
                    tail->next = list2;
                    tail = list2;//传地址
                    list2 = list2->next;
            }
    }
    if(list1)
    {
        tail->next = list1;//如果链表1不为空,而此时链表二为空,则直接把链表二的值连接过去就好了。
    }
    if(list2)
    {
        tail->next = list2;
    }
    //解决内存泄漏问题;
    struct ListNode* list = head->next;
    free(head);
    return list;
}

3、链表分割_牛客题霸_牛客网(链接)

思路:新设置两个链表,小于x的插到第一个链表,大于x的插到第二个链表。

定义四个指针:LessHead, LessTail,GreatHead, GreatTail.

原链表的值分别尾插到这两个链表, 然后分别更新LessTail,和GreatTail;

最后LessTail的指针再指向GreatHead。完成两个链表的连接。

想极端场景:

1、所有值比x小

2、所有值比x大

3、比x大和小都有,最后一个值是比x小

4、比x大和小都有,最后一个值是比x大

//构成环链表,造成死循环。
//设置哨兵位
class Partition {
  public:
    ListNode* partition(ListNode* pHead, int x) {
        struct ListNode* lessHead, *lessTail, *greatHead, *greatTail;
        lessHead = lessTail = (struct ListNode*)malloc(sizeof(struct ListNode));
        greatHead = greatTail = (struct ListNode*)malloc(sizeof(struct ListNode));
        lessTail->next = greatTail->next = NULL;
        struct ListNode* cur = pHead;
        while (cur) {
            if (cur->val < x) {
                lessTail->next = cur;
                lessTail = lessTail->next;
            } else {
                greatTail->next = cur;
                greatTail = greatTail->next;
            }
            cur = cur->next;
        }
        //完成链接工作
        lessTail->next = greatHead->next;
        greatTail->next = NULL;//切断greetTail的最后与greetHead的链接
        struct ListNode* list = lessHead->next;
        free(lessHead);
        free(greatHead);
        return list;
    }
};

4、链表的回文结构_牛客题霸_牛客网(链接)

思路:找出链表的中间节点, 然后逆置,判断前后链表是否一致,若一致,则说明该链表是回文结构。

为什么奇数个时也能过,

例如:1 2 3 2 1

逆置完变为了 1 2 1 2 3 ;

当A走到2的位置时2->next = 3, rHead走到的 2->next = 3, 相等。

class PalindromeList {
public:
    struct ListNode* middleNode(struct ListNode* head)
{
    struct ListNode* slow, * fast;
    slow = fast = head;
    while(fast && fast->next) //想的是结束的条件,写的是继续的条件
    {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}
    struct ListNode* reverseList(struct ListNode* head)
{
    struct ListNode* NewHead = NULL;
    struct ListNode* cur = head;
    while(cur)
    {
        struct ListNode* next = cur->next;
        //头插
        cur->next = NewHead;//更多代表链表的指向方向。
        NewHead = cur;//接着把地址传过来(更新)
        cur = next;//(更新)
    }
    return NewHead;
    }
    bool chkPalindrome(ListNode* A) {
        struct ListNode* mid = middleNode(A);
        struct ListNode*rHead = reverseList(mid);//应该逆置mid,中间结点。
        while(A && rHead)
        {
            if(A->val == rHead->val)
            {
                A = A->next;
                rHead = rHead->next;
            }
            else
            {
                return false;
            }
        }
        return true;
    }
};

5、力扣相交链表(链接)

思路1:A链表每个节点B跟链表依次比较,如果有相等,就是相交,第一个相等就是交点。

时间复杂度:o(N*M);

思路二:如果两个链表相交,则这两个链表的最后一个元素的地址相同。

包含思路二三:

代码示例:

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB)
{
    struct ListNode* tailA, *tailB;//因为之后还要用到headA,和headB,所以要用tail来进行迭代。
    tailA = headA, tailB = headB;
    int lenA = 1, lenB = 1;
    while(tailA)//求出A的尾
    {
        tailA = tailA->next;
        ++lenA;//求出A的长度
    }
    while(tailB)//求出链表B的尾
    {
        tailB = tailB->next;
        ++lenB;//求出B的长度
    }
    if(tailA != tailB)//如果两个链表的尾不相等,则返回空
    {
        return NULL;
    }
    //相交,求交点,长的先走差距步,再同时找交点。
    struct ListNode* shortList = headA, *longList = headB;//默认A短B长
    if(lenA > lenB)
    {
        shortList = headB;
        longList = headA;
    }
    int gap = abs(lenA - lenB);//求出差距
    while(gap--)//减gap次,若是--gap,就是减了gap - 1次
    {
        longList = longList->next;
    }
    while(shortList && longList)
    {
        if(shortList == longList)
        return shortList;//此时shortList == longList;
        longList = longList->next;
        shortList = shortList->next;
    }
    //最最关键的一步:就是要在外面返回一个值,因为编译器不会判断代码在哪返回,只会检查你的代码的语法问题。
    return NULL;
}

总结

本文分别从双向链表的概念、实现,还比较了顺序表和链表的区别,以及5道链表oj题四个方面介绍了链表进阶的知识,希望大家读后能够有所收获。

到此这篇关于C语言超详细i讲解双向链表的文章就介绍到这了,更多相关C语言双向链表内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • C语言数据结构 双向链表的建立与基本操作

    C语言数据结构 双向链表的建立与基本操作 双向链表比单链表有更好的灵活性,其大部分操作与线性表相同.下面总结双向链表与单链表之间的不同之处及我在实现过程中所遇到的问题. 1.双向链表的建立 双向链表在初始化时,要给首尾两个节点分配内存空间.成功分配后,要将首节点的prior指针和尾节点的next指针指向NULL,这是十分关键的一步,因为这是之后用来判断空表的条件.同时,当链表为空时,要将首节点的next指向尾节点,尾节点的prior指向首节点. 2.双向链表的插入操作 由于定义双向链表时指针域中

  • C语言双向链表的原理与使用操作

    目录 一.引入 二.双向链表的定义 三.双向链表与单链表对比 3.1图示对比 3.2代码对比 四.双向链表的操作 4.1双向链表的创建 4.2双向链表的插入 4.3双向链表的删除 4.4双向链表的销毁 五.总结 六.全部代码 一.引入 我们在单链表中,有了next指针,这个指针是用来指向下一个节点的,如果我们需要查找下一个结点的时间复杂度为o(1),如果我们需要查找上一个节点的时候,那么时间复杂度就变为o(n)了,需要从头进行遍历一遍:这时我们就会想:如果可以向前查找就方便了许多,因此我们引入了

  • C语言算法学习之双向链表详解

    目录 一.练习题目 二.算法思路 1.设计浏览器历史记录 2.扁平化多级双向链表 3.展平多级双向链表 4.二叉搜索树与双向链表 一.练习题目 题目链接 难度 1472. 设计浏览器历史记录 ★★★☆☆ 430. 扁平化多级双向链表 ★★★☆☆ 剑指 Offer II 028. 展平多级双向链表 ★★★☆☆ 剑指 Offer 36. 二叉搜索树与双向链表 ★★★★☆ 二.算法思路 1.设计浏览器历史记录 1.这是一个模拟题: 2.初始化生成一个头结点,记录一个当前结点: 3.向前 和 向后 是两

  • C语言之双向链表详解及实例代码

    1,双向链表简介. 双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱.所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点.一般我们都构造双向循环链表. 2,例子要求: 完成双向链表的插入.删除以及查找,将学生管理系统使用的数组,以双向链表的方式实现,能够支持无限制的学生人数的增删改查以及保存. 3,代码实现. #include <stdio.h> #include <string.h> #include <

  • C语言实现双向链表

    这个小代码是我凭自己对指针和链表的理解和认识,自己实现的,没有参考其他人的代码,如果有相同的地方,那真的只是巧合,代码我在ubuntu 15.04下测试通过,可能存在很多错误和漏洞. doublelist.c /************************************************************************* > File Name: doublelist.c > Author: ChenYiLiang > Mail: chenyilian

  • C语言类的双向链表详解

    目录 前言 双向链表的定义 双向链表的创建 节点的创建 双向链表节点查找 双向链表的插入 双向链表的节点删除 双向链表的删除 总结 前言 链表(linked list)是一种这样的数据结构,其中的各对象按线性排列.数组的线性顺序是由数组下标决定的,然而于数组不同的是,链表的各顺序是由链表中的指针决定的. 双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱.所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点.一般我们都构造双向循

  • C语言中双向链表和双向循环链表详解

    双向链表和双向循环链表 和单向链表相比,多了一个前驱结点.如果他为空,那么next和prior都指向自己.而对于双循环链表,只需要最后一个元素的next指向head->next,head->next的prior指向最后一个节点即可. 插入操作 新节点s插入链表,s->next给p结点,s->prior给p->prior,然后,p->prior->next指向s,p->prior再指向s.顺序需要注意 s->next = p; s->prior =

  • C语言 数据结构双向链表简单实例

    双向链表的基本操作 1.利用尾插法建立一个双向链表. 2.遍历双向链表. 3.实现双向链表中删除一个指定元素. 4.在非递减有序双向链表中实现插入元素e仍有序算法. 5.判断双向链表中元素是否对称若对称返回1否则返回0. 6.设元素为正整型,实现算法把所有奇数排列在偶数之前. 7.在主函数中设计一个简单的菜单调试上述算法. 实例代码: //排序的时候因为没有说明奇数和偶数需不需要各自再排序,我就没有排序,只是将奇数放在偶数后面. //创建链表的时候,因为这个实验没有要求输出链表的长度,所以我就输

  • C语言实现数据结构和双向链表操作

    数据结构  双向链表的实现 双向链表中的每一个结点都含有两个指针域,一个指针域存放其后继结点的存储地址,另一个指针域则存放其前驱结点的存储地址. 双向链表结点的类型描述: //双向链表的类型描述 typedef int ElemType; typedef struct node{ ElemType data; struct node *prior,*next; }DuLNode,*DuLinkList; 其中,prior域存放的是其前驱结点的存储地址,next域存放的是其后继结点的存储地址. 双

  • C语言超详细i讲解双向链表

    目录 一.双向链表的概念 二.双向链表的实现 三.链表与顺序表的差别 四.链表oj 总结 一.双向链表的概念 1.概念:概念:双向链表是每个结点除后继指针外还有⼀个前驱指针.双向链表也有带头结点结构和不带头结点结构两种,带头结点的双向链表更为常用:另外,双向链表也可以有循环和非循环两种结构,循环结构的双向链表更为常用. 二.双向链表的实现 头文件List.h #pragma once #include<stdio.h> #include<assert.h> #include<

  • C语言 超详细总结讲解二叉树的概念与使用

    目录 1.二叉树的概念及结构 2.二叉树链式结构的实现 1.二叉树的概念及结构 ①概念:一棵二叉树是结点的一个有限集合,该集合或者为空,或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成. ②二叉树的特点: 每个结点最多有两棵子树,即二叉树不存在度大于2的结点.(度最多为2) 二叉树的子树有左右之分,其子树的次序不能颠倒. ③现实中的二叉树: 当一名普通的人看到这样一颗树,可能会想:好标准的一棵树 当一个程序猿看到这样一棵树,可能会想:好像数据结构中的二叉树,并且还是颗满二叉树 ④数据结

  • C语言超详细讲解数据结构中双向带头循环链表

    目录 一.概念 二.必备工作 2.1.创建双向链表结构 2.2.初始化链表 2.3.动态申请节点 2.4.打印链表 2.5.销毁链表 三.主要功能 3.1.在pos节点前插入数据 尾插 头插 3.2.删除pos处节点数据 尾删 头删 3.3.查找数据 四.总代码 List.h 文件 List.c 文件 Test.c 文件 五.拓展 一.概念 前文我们已经学习了单向链表,并通过oj题目深入了解了带头节点的链表以及带环链表,来画张图总体回顾下: 在我们学习的链表中,其实总共有8种,都是单双向和带不带

  • C语言 超详细讲解链接器

    目录 1 什么是链接器 2 声明与定义 3 命名冲突 3.1 命名冲突 3.2 static修饰符 4 形参.实参.返回值 5 检查外部类型 6 头文件 1 什么是链接器 典型的链接器把由编译器或汇编器生成的若干个目标模块,整合成一个被称为载入模块或可执行文件的实体–该实体能够被操作系统直接执行. 链接器通常把目标模块看成是由一组外部对象组成的.每个外部对象代表着机器内存中的某个部分,并通过一个外部名称来识别.因此,==程序中的每个函数和每个外部变量,如果没有被声明为static,就都是一个外部

  • C语言 超详细讲解库函数

    目录 1 返回整数的getchar函数 2 更新顺序文件 3 缓冲输出与内存分配 4 库函数 练习 1 返回整数的getchar函数 代码: #include<stdio.h> int main() { char c; while((c = getchar())!=EOF)//getchar函数的返回值为整型 putchar(c); return 0; } 上述代码有三种可能: 某些合法的输入字符在被"截断"后使得c的取值与EOF相同,程序将在复制的中途停止. c根本不可能

  • C语言 超详细讲解算法的时间复杂度和空间复杂度

    目录 1.前言 1.1 什么是数据结构? 1.2 什么是算法? 2.算法效率 2.1 如何衡量一个算法的好坏 2.2 算法的复杂度 2.3 复杂度在校招中的考察 3.时间复杂度 3.1 时间复杂度的概念 3.2 大O的渐进表示法 3.3 常见时间复杂度计算举例 4.空间复杂度 5. 常见复杂度对比 1.前言 1.1 什么是数据结构? 数据结构(Data Structure)是计算机存储.组织数据的方式,指相互之间存在一种或多种特定关系的数据元素的集合. 1.2 什么是算法? 算法(Algorit

  • C语言超详细讲解字符串相乘

    目录 前言 一. 分析思路 二.使用步骤 1.代码如下 2.memset函数 三.总结 前言 我们已经知道,正常的两位整形数据通过*相乘,C语言中int为4字节,32bit(字节),其机器码第一位为符号位,余下31位表示数字,表示范围:-2^31(-2147483648)~2^31-1(2147483647),但超过了这个范围我们该如何做呢? 提示:将数字以字符串的形式进行操作 一. 分析思路 示例: 我们把每一个数都看成是一个字符串,每一个元素为十进制数字所对应的字 符,由于是后面的元素先进行

  • C语言超详细讲解排序算法上篇

    目录 1.直接插入排序 2.希尔排序(缩小增量排序) 3.直接选择排序 4.堆排序 进入正式内容之前,我们先了解下初阶常见的排序分类 :我们今天讲前四个! 1.直接插入排序 基本思想:当插入第i(i>=1)个元素时,前面的array[0],array[1],…,array[i-1]已经排好序,此时用array[i]的排 序码与array[i-1],array[i-2],…的排序码顺序进行比较,找到插入位置即将array[i]插入,原来位置上的元素顺序后移! 直接插入排序的特性总结: 1. 元素集

  • C语言超详细讲解栈与队列实现实例

    目录 1.思考-1 2.栈基本操作的实现 2.1 初始化栈 2.2 入栈 2.3 出栈 2.4 获取栈顶数据 2.5 获取栈中有效元素个数 2.6 判断栈是否为空 2.7 销毁栈 3.测试 3.1测试 3.2测试结果 4.思考-2 5.队列的基本操作实现 5.1 初始化队列 5.2 队尾入队列 5.3 队头出队列 5.4 队列中有效元素的个数 5.5 判断队列是否为空 5.6 获取队头数据 5.7 获取队尾的数据 5.8 销毁队列 6.测试 6.1测试 6.2 测试结果 1.思考-1 为什么栈用

  • C语言超详细讲解轮转数组

    目录 题目描述 实例 解题思路 1. 先整体逆转 2.逆转子数组[0, k - 1] 3.逆转子数组[k, numsSize - 1] 易错点 代码 题目描述 给你一个数组,将数组中的元素向右轮转 k 个位置,其中 k 是非负数.OJ链接 实例 1.实例1 输入: nums = [1,2,3,4,5,6,7], k = 3输出: [5,6,7,1,2,3,4]解释:向右轮转 1 步: [7,1,2,3,4,5,6]向右轮转 2 步: [6,7,1,2,3,4,5]向右轮转 3 步: [5,6,7

随机推荐