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

最新推荐文章于 2024-07-09 19:36:25 发布
最新推荐文章于 2024-07-09 19:36:25 发布
阅读量46 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kqs__/article/details/132206870
版权

文章目录 

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);
}

 

kqs__
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
九度OJ 题目1181：遍历链表
落日小屋
02-20 2224
题目1181：遍历链表 时间限制：1 秒 内存限制：32 兆 特殊判题：否 提交：1071 解决：437 题目描述： 建立一个升序链表并遍历输出。 输入： 输入的每个案例中第一行包括1个整数：n(1 输出： 可能有多组测试数据，对于每组数据， 将n个整数建立升序链表，之后遍历链表并输出。 样例输入
LeetCode/NowCoder-栈和队列OJ练习
Become Mad的博客
05-28 1163
数据结构的学习离不开刷题，题刷的够多才能有题感，才能有把握，这个系列专门更新数据结构相关的习题、面试题，欢迎大家来学习~
【链表OJ 11】复制带随机指针的链表
weixin_65186652的博客
09-05 2194
【链表OJ 11】复制带随机指针的链表，c语言实现，详解
【万字详解栈和队列及其OJ题】
m0_68872612的博客
08-19 490
各位大佬们，今天分享的是栈和队列的实现以及相关OJ题，如果觉得不错的话能支持一下菜鸟吗？
【数据结构】栈和队列OJ练习(栈和队列相互实现+循环队列实现)
Edward_Asia的博客
11-03 2591
前言 前面在学习了栈和队列的实现之后，相信大家对栈和队列的结构和使用方式都有了一些理解。 下面我们就来进行一些练习，这这章的练习相对于原来在难度上有了一些提升。 原来的题只需要实现一个接口，而今天的练习题需要实现多个接口。 1.用队列实现栈 225. 用队列实现栈 - 力扣（LeetCode） (leetcode-cn.com) 栈：后进先出；队列：先进先出 方法： 创建两个队列，用来来回导数据。 入栈：将数据放入不为空的队列。 出栈：将不为空的队列中的数据以出队入栈的方式.
栈和队列的实现以及相关OJ题目
qq_57770005的博客
05-24 358
栈和队列的实现以及相关OJ题目一、栈1.栈的概念及结构2.栈的动态实现3.有关于栈的OJ题目3.1括号匹配问题二、队列1.队列的概念以及结构2.队列的实现3.队列的OJ题目3.1用队列实现栈3.2用栈实现队列3.3循环队列总结 一、栈 1.栈的概念及结构 栈：是一种特殊的·线性表，其只允许在固定的一端进行插入和删除元素操作 进行数据插入和删除操作的一端成为栈顶，另一端成为栈底。 栈遵循的原则：是先进后出。 2.栈的动态实现 栈的实现一般可以使用数组或者链表来实现，相对而言数组的结构实现会更优， 因为在
链表OJ11——随机链表的复制（C++代码实现）
2301_80224556的博客
04-23 412
【代码】链表OJ11——随机链表的复制（C++代码实现）
数据结构——链表OJ题
Renswc的博客
02-20 2599
链表oj题练习，链表尾插，我们可以用一个tail指针来记录尾插后的节点，尾插直接在tail节点后即可，这样就不用每次尾插都循环遍历，大大减少了时间复杂度 ，提高了运行效率。
栈和队列OJ题合集(包含循环队列的两种实现)
2301_76269963的博客
04-01 1420
栈和队列OJ题合集(包含循环队列的两种实现)
OJ题目【栈和队列】
2301_80216111的博客
06-04 1016
栈和队列的OJ题目
OJ.zip_循环链表
09-21
在这个"OJ.zip_循环链表"的案例中，我们利用循环链表来解决约瑟夫问题。首先，我们需要创建一个链表节点类，包含数据（如人编号）和指向下一个节点的指针。然后，我们可以初始化一个循环链表，将所有参与者的编号...
cpp代码-双向循环链表-oj
07-14
总结起来，"cpp代码-双向循环链表-oj"主题涵盖了C++实现双向循环链表的原理、结构和操作方法，同时强调了在实际编程环境中，特别是在在线判题系统上的应用。通过对`main.cpp`文件的学习和调试，开发者可以深化对链表...
西南科技大学SWUST OJ 线性结构，链表题解答案 线性结构.zip
12-31
《西南科技大学SWUST OJ线性结构链表题解答案详解》 在计算机科学中，线性结构是一种基本的数据组织形式，它包含了数组和链表等常见数据结构。本资料集中，我们主要关注的是链表相关的题目解答，这些题目来自西南...
数据结构--树和二叉树的一些知识点总结
weixin_68489989的博客
07-09 301
数据结构--树和二叉树的一些知识点总结
数据结构 Java DS——链表部分经典题目 (1)
cjejwe的博客
07-09 237
笔者计划在暑假啃完JavaDS,Mysql的内容当然也会继续更这次给读者们分享的是链表的几个比较典型的题目,关于如何手搓一个链表,笔者还在筹划中,毕竟链表的种类也有那么多,但是在下面的题目中,只有单向链表。
Redis教程(二十三)：Redis的底层数据结构
十三月的博客
07-09 24
Redis是一种高性能的key-value数据库，广泛用于缓存、消息队列、应用程序会话管理等领域。它之所以能提供高效的数据操作性能，很大程度上归功于其底层使用了多种优化过的数据结构来存储数据。
数据结构第07节：队列
hummhumm的专栏
07-04 550
在计算机科学中，队列是一种抽象数据类型，它遵循先进先出（FIFO）原则，即最先加入队列的元素将是最先被移除的。在学生成绩管理系统中，队列可以用于管理等待处理的成绩更新请求，或者用于存储等待查询成绩的学生ID列表。请注意，这个实现假设所有学生ID都是整数，并且队列的大小是固定的。这个队列将用于管理学生的ID，模拟学生成绩管理系统中可能用到的队列操作。下面，我将以一个简单的学生成绩管理系统中的队列应用为例，用表格形式来详细讲解队列的操作和状态变化。类，它包含书籍的基本信息，例如书名、作者和ISBN号。
数据结构--顺序表
LH__1314的博客
06-30 4899
当我们想要使⽤大量使⽤同⼀类型的数据时，通过⼿动定义⼤量的独立的变量对于程序来说，可读性非常差，我们可以借助数组这样的数据结构将⼤量的数据组织在⼀起，结构也可以理解为组织数据的方式。在使用完顺序表后，就要销毁顺序表，因为动态顺序表内存是动态开辟的，所以需要对动态内存进行释放，并将有效数据和空间容量个数置为0；到这里，顺序表的知识就完成了，学完这些，我们也要写顺序表的实践，就是通讯录——在下一篇进行实现。求数组的长度，求数组的有效数据个数，向下标为数据有效个数的位置插入数据（注意：这里是。
数据结构双向循环链表
最新发布
picians的博客
07-09 416
printf("链表已空，无需遍历\n");printf("链表已空，无需删除\n");printf("入参为空，请检查\n");printf("入参为空，请检查\n");printf("入参为空，请检查\n");printf("入参为空，请检查\n");printf("入参为空，请检查\n");printf("入参为空，请检查\n");printf("节点申请失败\n");printf("节点申请失败\n");
旋转链表 东华大学oj
06-03
旋转链表是一种操作链表的方法，它可以将链表中的元素向右...旋转链表的主要应用场景是在某些需要处理循环数组的问题中，将链表视为循环数组来处理。 关于东华大学oj的问题，我不是很清楚，可以请您提供更多的信息吗？

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值