链表oj(复制随机链表)、栈和队列oj(循环队列)

news2025/1/16 6:50:45

文章目录 

1.链表oj

2.栈和队列oj

文章内容

1.链表oj

1. 给定一个链表，每个结点包含一个额外增加的随机指针，该指针可以指向链表中的任何结点
或空结点。要求返回这个链表的深度拷贝。力扣

  该题不仅要求复制链表，而且每个节点有两个指针域，一个指向下一个节点，一个指向随机节点。

思路一：暴力求解

第一，复制一个链表出来

第二，复制random，但是原链表random指向的下一个节点，如何在复制的链表中找到？

   我们可以通过原链表的数据域来确定吗？如果不同节点存储相同的数据，这时我们怎么去判定复制节点中random所指向的节点呢？我们可以将每个节点的下标，以及random指向节点的下标单独存储起来，这样我们在复制的链表中便可以轻松找到random指向的节点。但是这种方法的空间复杂度是O(N^2)。不妨换种思路？！！

 思路二：

 

思路图：

struct Node* copyRandomList(struct Node* head) {

    struct Node* cur = head;
    
    //在原节点后链接新节点
    while(cur)
    {
        struct Node* next =cur->next;
        struct Node* copy = (struct Node*)malloc(sizeof(struct Node));
        copy->val = cur->val;

        //链接
        cur->next = copy;
        copy->next = next;

        cur = next;
    }

    //复制random

    cur = head;
    while(cur)
    {
        struct Node* copy = cur->next;
        struct Node* next = copy->next;

        if(cur->random == NULL)
        {
        copy->random = NULL;
        }
        else
        {
        copy->random = cur->random->next;
        }

        //往后走
        cur = next;

    }

 cur = head;
  struct Node* copyhead = NULL;
  struct Node* copytail = NULL;
        
    while(cur)
    {

        struct Node* copy = cur->next;
        struct Node* next = copy->next;

        if(copytail == NULL)
        {
            copyhead = copytail = copy;
        } 
        else
        {
            copytail->next = copy;

            copytail = copytail->next;
        }
      //恢复原链表
       cur->next = next;
       cur = next;
    }
 
	return copyhead;
}

2.栈和队列oj

1. 括号匹配问题。力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

思路：将所有的左括号入栈，而右括号不入栈。栈顶的元素都需要与下一个不入栈的元素(也就是右括号)，相比较看是否为同一类型的，这样设计从前到后比较了每一对相邻最近的左、右括号。假如某一对相邻最近的左、右括号不匹配便返回假。

 

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;

void STInit(ST* ps);
void STDestroy(ST* ps);
void STPush(ST* ps, STDataType x);
void STPop(ST* ps);
STDataType STTop(ST* ps);

int STSize(ST* ps);
bool STEmpty(ST* ps);

void STInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

void STDestroy(ST* ps)
{
	assert(ps);

	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

void STPush(ST* ps, STDataType x)
{
	assert(ps);
	// 11:40
	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity = newCapacity;
	}

	ps->a[ps->top] = x;
	ps->top++;
}

void STPop(ST* ps)
{
	assert(ps);

	// 
	assert(ps->top > 0);

	--ps->top;
}

STDataType STTop(ST* ps)
{
	assert(ps);

	// 
	assert(ps->top > 0);

	return ps->a[ps->top - 1];
}

int STSize(ST* ps)
{
	assert(ps);

	return ps->top;
}

bool STEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}

bool isValid(char * s){

        ST st;
        STInit(&st);
        char topval;

        while(*s)
        {
            if(*s == '(' || *s == '{'  || *s == '[')
            {
                STPush(&st,*s);
            }
            else
            {
                if(STEmpty(&st))
                {
					STDestroy(&st);
                    return false;
                }

                topval = STTop(&st);
                STPop(&st);

                if((*s == ')' && topval != '(' )
                ||(*s == ']' && topval != '[' )
                ||(*s == '}' && topval != '{' )
                )

                {
				 	STDestroy(&st);
                    return false;

                }

            }

        ++s;
        }

    bool ret = STEmpty(&st);
    STDestroy(&st);
    return ret;
}

2. 用队列实现栈。力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

 思路： 入队时入不为空的队列。出队队列时，不为空的队列的前n-1个元素入空队列，出不为空的队列的最后一个元素。也就是一个队列保持为空，一个保持不为空。

 

typedef int QDataType;

typedef struct QueueNode
{
	struct QueueNode * next;
	QDataType data;

}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Que;


//初始化
void QueueInit(Que* pq);


//销毁
void QueueDestroy(Que* pq);


//入队
void QueuePush(Que* pq, QDataType x);

//出队
void QueuePop(Que* pq);

//判空
bool QueueEmpty(Que* pq);


//取队头元素
QDataType QueueFront(Que* pq);

//去队尾元素
QDataType QueueBack(Que* pq);

//计数
int QueueSize(Que* pq);


//初始化
void QueueInit(Que* pq)
{
	pq->head = NULL;
	pq->tail = NULL;
	pq->size =0;
}


//销毁
void QueueDestroy(Que* pq)
{
	assert(pq);
    
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}

	pq->head = pq->tail = NULL;
	pq->size = 0;
}



//入队
void QueuePush(Que* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));

	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	newnode->data = x;
	newnode->next = NULL;

	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}

	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

	pq->size++;

}


//出队
void QueuePop(Que* pq)
{
	assert(pq);
	assert(! QueueEmpty(pq));
	
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head =pq->tail =  NULL;
	}
	
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;

	}
	pq->size--;
}

//取队头元素
QDataType QueueFront(Que* pq)
{
	assert(pq);
	assert(! QueueEmpty(pq));

	return pq->head->data;
}



//去队尾元素
QDataType QueueBack(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}




//判空
bool QueueEmpty(Que* pq)
{
	assert(pq);

	return pq->head == NULL;

}

//计数
int QueueSize(Que* pq)
{

	assert(pq);

	return pq->size;
}


typedef struct {
    Que q1;
    Que q2;
} MyStack;


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

    return pst;
}


void myStackPush(MyStack* obj, int x) {

    if(! QueueEmpty(&obj->q1))
    {
       QueuePush(&obj->q1,x);
    }
    else
    {
       QueuePush(&obj->q2,x);
    }

}


int myStackPop(MyStack* obj) {
    Que* empty = &obj->q1;
    Que* nonempty = &obj->q2;

    if(! QueueEmpty(&obj->q1))
    {
     empty = &obj->q2;
    nonempty = &obj->q1;

    }
    
    while(QueueSize(nonempty)>1)
    {

     QueuePush(empty,QueueFront(nonempty));
     QueuePop(nonempty);

    }
     int top = QueueFront(nonempty);
     QueuePop(nonempty);

    return top;

}

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

}

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

}

void myStackFree(MyStack* obj) {

    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);

    free(obj);
}

3. 用栈实现队列。力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

思路：两个栈，一个入元素，另一个出元素。当出元素的栈为空时候，将入元素的栈压入出元素的栈。

 

 

typedef int STDataType;

typedef struct Stcak
{
	STDataType* a;
	int top;
	int capacity;
}ST;


void STInit(ST* ps);

void STDestroy(ST* ps);

void STPush(ST* ps, STDataType x);

void STPop(ST* ps);

STDataType STTop(ST* ps);

int STSize(ST* ps);

bool STEmpty(ST* ps);

void STInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;

}


void STDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;

}


void STPush(ST* ps, STDataType x)
{
	assert(ps);

	if (ps->capacity == ps->top)
	{
		STDataType newcapacity = ps->capacity ==  0 ? 4: (ps->capacity)* 2;
		STDataType* tmp = (STDataType*) realloc(ps->a,sizeof(STDataType)* newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity = newcapacity;

	}
	ps->a[ps->top] = x;
	ps->top++;

}

void STPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);

	ps->top--;

}


STDataType STTop(ST* ps)
{
	assert(ps);

	assert(ps->top > 0);

	return ps->a[ps->top-1];
}

int STSize(ST* ps)
{
	assert(ps);

	return ps->top;

}

bool STEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}




typedef struct {
    ST pushst;
    ST popst;
    
} MyQueue;


MyQueue* myQueueCreate() {
  MyQueue* obj =(MyQueue*) malloc(sizeof(MyQueue));
  STInit(&obj->pushst);
  STInit(&obj->popst);
  return obj;

}


void myQueuePush(MyQueue* obj, int x) {
    STPush(&obj->pushst,x);
}


int myQueuePeek(MyQueue* obj) {
 

   if(STEmpty(&obj->popst))
    {
        while(!STEmpty(&obj->pushst))
        {
             STPush(&obj->popst,STTop(&obj->pushst));
             STPop(&obj->pushst);
        }
      
    }
    return STTop(&obj->popst);
}


int myQueuePop(MyQueue* obj) {

 int front =myQueuePeek (obj);
  STPop(&obj->popst);
  return front;
 
}


bool myQueueEmpty(MyQueue* obj) {
     return STEmpty(&obj->pushst) && STEmpty(&obj->popst);  
}

void myQueueFree(MyQueue* obj) {
    STDestroy(&obj->pushst);
    STDestroy(&obj->popst);
    free(obj);
}

 4. 设计循环队列。力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

 思路：

如何判断队列空 和 满 这是循环队列的关键所在，插入和弹出问题难度不大。

     

 pop(弹出)

 

 

typedef struct {
    int* a;
    int front;
    int rear;
    int k;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {

   MyCircularQueue* obj =  (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
   obj->a = (int* )malloc(sizeof(int) *(k+1));
   obj->rear = obj->front = 0;
   obj->k = k;
   return obj;

}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
         return obj->front == obj->rear;
}

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

}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
        return false;

    obj->a[obj->rear]= value;    
    obj->rear++;
    obj->rear %= obj->k+1;

    return true;

}

bool myCircularQueueDeQueue(MyCircularQueue* 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) {
    if(myCircularQueueIsEmpty(obj))
        return -1;

    else
    return obj->a[(obj->rear+obj->k)% (obj->k+1)];

}



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

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/914747.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【C语言】自定义类型（结构体+枚举+联合）

【C语言】自定义类型（结构体+枚举+联合）

一、结构体 1、结构体类型的声明 （1）结构的基础知识 结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。 （2）结构的声明 举例： // 形容一名学生 struct Stu {char name[20];…
阅读更多...
7.elasticsearch同步工具-logstah

7.elasticsearch同步工具-logstah

1.logstah Logstash 是一个用于数据处理和转换的开源工具，它可以将来自不同源头的数据收集、转换、过滤，并将其发送到不同的目标。Logstash 是 ELK（Elasticsearch、Logstash 和 Kibana）技术栈的一部分，通常与 Elastics…
阅读更多...
JVM理论知识

JVM理论知识

一、JVM内存结构 java的内存模型主要分为5个部分，分别是：JVM堆、JVM栈、本地栈、方法区还有程序计数器，他们的用途分别是： JVM堆：新建的对象都会放在这里，他是JVM中所占内存最大的区域。他又分为新生区还…
阅读更多...
无处不在的拉普拉斯——边缘，斑点，金字塔

无处不在的拉普拉斯——边缘，斑点，金字塔

作为拿破仑的老师和“法国牛顿”，拉普拉斯在数学和天体力学中贡献颇多，但其实在图像处理中也会发现拉普拉斯的身影。怎么它又可以用来检测斑点，又可以检测边缘，又可以金字塔重建，还可以平滑，还可以增强细节…
阅读更多...
redis 6个节点（3主3从），始终一个节点不能启动

redis 6个节点（3主3从），始终一个节点不能启动

redis节点，始终有一个节点不能启动起来 1.修改了配置文件 protected-mode no，重启 修改了配置文件 protected-mode no，重启redis问题依然存在 2、查看/var/log/message的redis日志 Aug 21 07:40:33 redisMaster kernel: Out of memory: K…
阅读更多...
Vue2-Vuex概念及使用场景、Vuex环境搭建、Vuex工作原理、Vuex配置项、Vuex模块化及命名空间

Vue2-Vuex概念及使用场景、Vuex环境搭建、Vuex工作原理、Vuex配置项、Vuex模块化及命名空间

🥔：山不向我走来，我便向它走去 更多Vue知识请点击——Vue.js VUE2-Day11 理解Vuex1、Vuex是什么2、什么时候使用Vuex Vuex环境搭建1、安装vuex2、创建store文件3、main.js引入store Vuex的工作原理1、原理图2、用案例解释工作原理3、注意点 V…
阅读更多...
linux之《进程》

linux之《进程》

文章目录 进程基础pcb状态优先级 进程的调度常见的调度算法 进程的通信方式 进程基础 pcb 操作系统在创建进程时，会给进程分配一块PCB（process control block 进程控制块），对应linux上就是task_struct结构体，PCB里面…
阅读更多...
非root用户下安装OpenSSL

非root用户下安装OpenSSL

1.OpenSSL下载 https://www.openssl.org/source/ 2.将下载好的压缩包上传至linux 3.解压压缩包 tar -xvf openssl-3.0.7.tar.gz 4.创建openssl安装目录 mkdir /home/openssl 5.进入安装包解压后的目录 cd /home/openssl-3.0.7.tar.gz 6.安装openssl，注意命令是…
阅读更多...
深度学习论文: WinCLIP: Zero-/Few-Shot Anomaly Classification and Segmentation

深度学习论文: WinCLIP: Zero-/Few-Shot Anomaly Classification and Segmentation

深度学习论文: WinCLIP: Zero-/Few-Shot Anomaly Classification and Segmentation WinCLIP: Zero-/Few-Shot Anomaly Classification and Segmentation PDF: https://arxiv.org/pdf/2303.14814.pdf PyTorch代码: https://github.com/shanglianlm0525/CvPytorch PyTorch代码: h…
阅读更多...
hexo优化bilibili显示

hexo优化bilibili显示

首发博客地址 https://blog.zysicyj.top/ It has been 1086 days since the last update, the content of the article may be outdated. 这篇文章属于转载，原地址为Hexo博客引用B站视频并自动适配 在进行引用B站用iframe方式引入视频时发现，通过默认的方…
阅读更多...
Python科研绘图--Task02

Python科研绘图--Task02

目录 图形元素 画布 (fifigure)。 坐标图形 (axes)，也称为子图。 轴 (axis) ：数据轴对象，即坐标轴线。 刻度 (tick)，即刻度对象。 图层顺序 轴比例和刻度 轴比例 刻度位置和刻度格式 坐标系 直角坐标系 极坐标系 地理…
阅读更多...
[oneAPI] 基于BERT预训练模型的SQuAD问答任务

[oneAPI] 基于BERT预训练模型的SQuAD问答任务

[oneAPI] 基于BERT预训练模型的SQuAD问答任务 Intel Optimization for PyTorch and Intel DevCloud for oneAPI基于BERT预训练模型的SQuAD问答任务语料介绍数据下载构建 模型 结果参考资料 比赛：https://marketing.csdn.net/p/f3e44fbfe46c465f4d9d6c23e38e0517 Int…
阅读更多...
多维时序 | MATLAB实现SABO-CNN-GRU-Attention多变量时间序列预测

多维时序 | MATLAB实现SABO-CNN-GRU-Attention多变量时间序列预测

多维时序 | MATLAB实现SABO-CNN-GRU-Attention多变量时间序列预测 目录 多维时序 | MATLAB实现SABO-CNN-GRU-Attention多变量时间序列预测预测效果基本介绍模型描述程序设计参考资料 预测效果 基本介绍 多维时序 | MATLAB实现SABO-CNN-GRU-Attention多变量时间序列预测。 模型描…
阅读更多...
算法通关村第九关——中序遍历与搜索树

算法通关村第九关——中序遍历与搜索树

1 中序遍历和搜索树原理 二叉搜索树按照中序遍历正好是一个递增序列。其比较规范的定义是： 若它的左子树不为空，则左子树上所有节点的值均小于它的根节点的值；若它的右子树不为空，则右子树所有节点的值均大于它的根节点的值&…
阅读更多...
17.2 【Linux】通过 systemctl 管理服务

17.2 【Linux】通过 systemctl 管理服务

systemd这个启动服务的机制，是通过一支名为systemctl的指令来处理的。跟以前 systemV 需要 service / chkconfig / setup / init 等指令来协助不同， systemd 就是仅有systemctl 这个指令来处理而已。 17.2.1 通过 systemctl 管理单一服务 （s…
阅读更多...
升级还是不升级？iPhone 15和iPhone 14 Plus性能比较

升级还是不升级？iPhone 15和iPhone 14 Plus性能比较

预览iPhone 15 Pro Max与三星Galaxy S23 Ultra之战是有正当理由的。显然，三星的旗舰智能手机为2023年的所有其他旗舰产品定下了基调——由于其超长的电池寿命和一流的摄像头，证明了它是最受欢迎的产品。 毫不奇怪，Galaxy S23 Ultra不仅是最好的照相手机之一，也是花钱能买到…
阅读更多...
docker之DockerFile与网络

docker之DockerFile与网络

目录 DockerFile 构建步骤 基础知识 指令 实战：构建自己的centos 第一步：编写dockerfile文件 第二步：构建镜像文件 docker网络 原理 功能 网络模式 host模式 container模式 none模式 bridge模式 DockerFile dockerfile 是用来…
阅读更多...
wireshark进行网络监听

wireshark进行网络监听

一、实验目的： 1）掌握使用CCProxy配置代理服务器； 2）掌握使用wireshark抓取数据包； 3）能够对数据包进行简单的分析。 二、预备知识： 包括监听模式、代理服务器、中间人攻击等知识点&#xf…
阅读更多...
【广州华锐视点】VR教学课件编辑工具有哪些用处？

【广州华锐视点】VR教学课件编辑工具有哪些用处？

随着科技的不断发展，教育领域也在不断地进行创新。在众多的创新技术中，虚拟现实(VR)技术的应用为教育带来了前所未有的变革。广州华锐视点开发的VR教学课件编辑工具作为一种新型的教育工具，可以为我们的教学提供许多支持，从而提升…
阅读更多...
redis基本介绍以及在node中使用

redis基本介绍以及在node中使用

文章目录 引言一、什么是redis1. redis简介2. redis的特点3. redis的应用场景 二、redis在windows下安装1. 下载安装2.验证是否安装成功3. 配置环境变量 三、redis-cli常用命令介绍1. redis-cli2. keys *3. set key value4. get key5. exists key6. del key7. info8. flushdb9.…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023