数据结构刷题

已于 2023-11-17 18:43:35 修改
阅读量362 收藏 1
点赞数 3
文章标签： 算法
于 2023-11-16 19:27:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dwededewde/article/details/134082802
版权

空间复杂度：临时开辟的空间、空间是可以重复利用的

递归为O(n)

时间复杂度：程序执行次数

消失的数字

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

思路1：利用连续的特点求等差和然后减去所有元素得到的就是消失的数字

时间复杂度：O(n)     空间复杂度：O(1)

思路2：将给定数组的元素和连续的元素进行异或（异或与顺序无关），相同元素异或结果为0。会得到有一个落单的数字与0异或就是这个数字。

时间复杂度：O(n)     空间复杂度：O(1)

第一种方法大家自行实现，我们可以实现一下不常见的第二种方法：

int missingNumber(int* nums, int numsSize){
    int x = 0;//0与任何数异或为该数
    for(int i = 0;i<numsSize;i++)
    {
        x ^= nums[i];
    }
     for(int i = 0;i<=numsSize;i++)
     {
          x ^= i;
     }
     return x;
}

轮转数组

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

c语言阶段曾实现了两种方法，一种是依次移动,移动M次。一种是局部逆置和整体逆置。前者时间复杂度为O(N*M),后者为O(N)

空间换时间：创建一个临时数组，前面放需要旋转的数据，后面放没有旋转的数据即可。 

不完整代码： 

void rotate(int* nums, int numsSize, int k){
    int tmp[numsSize];
    k %= numsSize;//循环次数不必多于元素个数
    int i = 0;
    int j = 0;
    for(i=numsSize-k;i<numsSize;i++)
    {
        tmp[j] = nums[i];
        j++;
    }
    for(i = 0;i<numsSize-k;i++)
    {
        tmp[j] = nums[i];
}
for//打印
}

有效的括号

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

思路：让左括号依次入栈，与右括号匹配。

匹配前：判断栈是否为空，为空说明无左括号。返回false。

匹配中：匹配涉及多次如 " () {} (())",记录指针位置与栈顶比较，然后出栈，不匹配返回false。

匹配结束：栈空为匹配成功，否则匹配失败。

注意返回前都需进行销毁操作。

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef char STDatatype;
typedef struct Stack
{
	STDatatype* a;
	int capacity;
	int top;
}ST;
void check_capacity(ST* ps)
{
     if(ps->capacity == ps->top)
    {
        int newCapacity = 0 ? 4:ps->capacity*2;
        char* tmp;
        tmp = (STDatatype*)realloc(ps->a,sizeof(STDatatype) * newCapacity);
	    if (tmp == NULL)
	    {
		    perror("malloc");
		    exit(-1);
	    }
        ps->a = tmp;
	    ps->capacity = newCapacity;
    }
}
bool StackEmpty(ST* ps)//判空
{
	assert(ps);
	return ps->top == 0;
}
STDatatype StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top-1];//top为最后一个元素的下一个
}
void StackDestroy(ST* ps)
{
	assert(ps);

	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
void StackInit(ST* ps)
{
	/*ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;*/
	//初始化空间
	ps->a = (STDatatype*)malloc(sizeof(STDatatype) * 4);
	if (ps->a == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	ps->top = 0;
	ps->capacity = 4;
}
void StackPop(ST* ps)//出栈
{
	assert(ps);
	//if(ps->top>0)
	assert(!StackEmpty(ps));
		ps->top--;
}
void StackPush(ST* ps, STDatatype x)
{
	assert(ps);
	check_capacity(ps);
	ps->a[ps->top] = x;
	ps->top++;//指向下一个
}
bool isValid(char* s) {
    ST ps;
    StackInit(&ps); 
while(*s)
{
	if(*s == '(' || *s == '[' ||*s == '{' )
    {
        StackPush(&ps,*s);
        s++;
    }
		else
		{
        if(StackEmpty(&ps))//如果没有左括号，栈顶没有元素
        {
            StackDestroy(&ps);//注意返回前都要手动释放空间
            return false;
        }
        char top = StackTop(&ps);
        if((*s == ')' && top != '(') || (*s == ']' && top != '[') ||
        (*s == '}' && top != '{'))//
        {
            StackDestroy(&ps);
            return false;
        }
        else
        {
            StackPop(&ps);
            s++;
        }
		}
}
bool ret = StackEmpty(&ps);
StackDestroy(&ps);
return ret;
}

用队列实现栈

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

先导入我们实现过的队列：

#pragma once
#include <stdbool.h>
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef int QDataType;
typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}QNode;
struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
};
void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
bool QueueEmpty(Queue* pq);
int QueueSize(Queue* pq);

void QueueDestroy(Queue* 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(Queue* 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;
	pq->size++;

	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}
void QueuePop(Queue* pq)
{
	//出队头删
	assert(pq);
	assert(pq->head);
	QNode* del = pq->head;
	pq->head = pq->head->next;
	free(del);
	if (pq->head == NULL)
		pq->tail = NULL;
	pq->size--;
	 
}
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = NULL;
	pq->tail = NULL;
	pq->size = 0;
}
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL && pq->tail == NULL;
}
int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->head->data;
}
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

 两个队列

将两个队列封装在一个结构体中。

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;//简写

创建并初始化链表(栈）

注意要想保证我们创建的结构体生命周期能够贯彻整个工程，必须在堆上申请空间。

MyStack* myStackCreate() {//创建并初始化链表
    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));//堆区
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);
    return obj;
}

模拟入栈

选择非空队列插入即可。

void myStackPush(MyStack* obj, int x) {
    if(!QueueEmpty(&obj->q1))//非空队列插入
    {
        QueuePush(&obj->q1,x);
    }
    else
        QueuePush(&obj->q2,x);
}

模拟出栈

出栈是在队尾进行出(后进先出)，我们将非空队列进行出队只剩下最后一个元素即是栈顶的元素，然后将其保存后出栈避免造成内存泄露，然后返回。

nt myStackPop(MyStack* obj) {
    //假定一方不为空
    Queue* empty = &obj->q1;
    Queue* nonempty = &obj->q2;
    if(!QueueEmpty(empty))
    {
          empty = &obj->q2;
        nonempty = &obj->q1;
    }
    
    while(QueueSize(nonempty) > 1)//O(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);
}

用栈实现队列

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

思路:两个栈，一个负责push数据，一个负责pop数据，在pop数据时，判断pop栈中是否有数据，没有则将push栈的数据全部导入，此时数据顺序反过来后再pop栈里出栈就可以实现先进先出这一特性了。

导入实现好的栈：


#include <stdbool.h>
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

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

void StackInit(ST* ps);
void StackDestroy(ST* ps);
void StackPush(ST* ps, STDatatype x);
void StackPop(ST* ps);//出栈
STDatatype StackTop(ST* ps);

bool StackEmpty(ST* ps);
int StackSize(ST* ps);

void StackInit(ST* ps)
{
	/*ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;*/
	//初始化空间
	ps->a = (STDatatype*)malloc(sizeof(STDatatype) * 4);
	if (ps->a == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	ps->top = 0;
	ps->capacity = 4;
}

static void check_capacity(ST* ps)
{
	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity * 2;
		STDatatype* tmp = (STDatatype*)realloc(ps->a, newCapacity *sizeof(STDatatype));
		if (tmp == NULL)
		{
			perror("realloc");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity == newCapacity;
		}
	}
}
void StackPush(ST* ps, STDatatype x)
{
	assert(ps);
	check_capacity(ps);
	ps->a[ps->top] = x;
	ps->top++;//指向下一个
}
void StackPop(ST* ps)//出栈
{
	assert(ps);
	//if(ps->top>0)
	assert(!StackEmpty(ps));
		ps->top--;
}

STDatatype StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top-1];//top为最后一个元素的下一个
}
void StackDestroy(ST* ps)
{
	assert(ps);

	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
bool StackEmpty(ST* ps)//判空
{
	assert(ps);
	return ps->top == 0;
}
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

两个栈

typedef struct {
    ST pushst;//入队
    ST popst;//出队
} MyQueue;

Create


MyQueue* myQueueCreate() {
        //初始化+开空间
    MyQueue* st = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&st->pushst);
    StackInit(&st->popst);
    return st;
}

Push

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

判空 

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

查看队头

由于popst的栈顶为队头，如果该栈为空，需要导入pushst的数据。

int myQueuePeek(MyQueue* obj) {
    assert(obj);
	assert(!myQueueEmpty(obj)); //双栈判空
		if(StackEmpty(&obj->popst))
		{
			while(!StackEmpty(&obj->pushst))//导数据
			{
				StackPush(&obj->popst,StackTop(&obj->pushst));
                StackPop(&obj->pushst);
			}
		}
    return StackTop(&obj->popst);
}

Pop

同样涉及判空和调用队头元素，通过调用peek函数判断并完成对数据的导入并接收其返回值，

int myQueuePop(MyQueue* obj) {
  
      int qhead = myQueuePeek(obj);
      StackPop(&obj->popst);//出队
      return qhead;
}

释放

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

小C您好
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
大厂算法和数据结构刷题
07-28
大厂算法和数据结构刷题java实现
数据结构刷题总结
loveyourz1的博客
05-03 551
将字符串 “abc” 插入到 t 中的任意位置。形式上，t 变为 tleft + “abc” + tright，其中 t == tleft + tright。注意，tleft 和 tright 可能为 空。栈善于处理消消乐这类配对问题。并且可以同时string和queue来模拟栈。如果字符串 s 有效，则返回 true；否则，返回 false。给你一个字符串 s ，请你判断它是否 有效。
7天带你全方位刷爆数据结构与算法，每天一道，高效刷题
SQY0809的博客
06-09 455
很多算法小白初期刷题比较迷茫，不知道从何刷起从何入手，也不知道怎么使用LeetCode，这篇带你高效使用力扣，让刷题进大厂的路上不再迷茫！
数据结构与算法【Leetcode - 力扣】超详细算法刷题笔记（更新中）
唤醒手腕的博客
10-13 1323
题目描述：大家都知道斐波那契数列，现在要求输入一个正整数 n ，请你输出斐波那契数列的第 n 项。斐波那契数列是一个满足： fib(x)={x=1x=0,x=2y=fib(x−1)+fib(x−2)x>2 fib(x)=\left\{ \begin{aligned} x & = & 1 && x = 0, x=2 \\ y & = & fib(x-1)+fib(x-2) && x >2\end{aligned} \right. fib(x)={xy​==​1fib(x−1)+fib(x−2)​​x=0,
数据结构算法刷题模板
zhaicheng55的博客
03-10 490
如果可以，写出这个递归函数的定义，并充分利用这个函数的返回值。
大厂算法和数据结构刷题班.zip
01-01
"大厂算法和数据结构刷题班.zip"很可能是为准备这类挑战而设计的学习资料，包含了针对这些公司面试的算法和数据结构训练题目。 数据结构主要包括数组、链表、栈、队列、哈希表、树（二叉树、平衡树、堆）、图等。每...
蓝桥杯真题解析，常用算法和数据结构刷题
最新发布
01-23
蓝桥杯真题解析，常用算法和数据结构刷题，RAS解密，等差数列，迷宫，方格分割等等 蓝桥杯真题解析，常用算法和数据结构刷题，RAS解密，等差数列，迷宫，方格分割等等 蓝桥杯真题解析，常用算法和数据结构刷题，RAS...
LeetCode 算法、数据结构刷题集~~~.zip
01-04
《LeetCode算法、数据结构刷题集》是一个包含JavaScript实现的LeetCode算法解题集合，主要针对数据结构和算法的学习与实践。这个压缩包中，我们重点探讨的是如何通过编程解决实际问题，尤其是数据处理和分析领域的...
期末刷题数据结构习题集
10-05
数据结构习题集 数据结构是计算机科学中的一种重要概念，涉及到数据的存储、组织和操作。下面是根据所给文件信息生成的知识点摘要： 1. 字符串是一种数据结构，串是字符的有限序列，空串是由空格构成的串，模式...
DataStructure：图解数据结构刷题代码
02-09
《数据结构：图解刷题代码解析》 在编程领域，数据结构是基础中的基础，它关乎程序的效率和可维护性。本资料主要聚焦于使用Java语言来理解和实现常见数据结构，结合LeetCode上的算法题目，以实战的方式加深对数据...
数据结构VIP刷题指南.pdf
03-24
数据结构刷题，数据结构基础的内容
GitHub一战封神，字节跳动内部顶级数据结构刷题学习笔记根本停不下来（csdn）————程序.pdf
12-01
标题和描述中提到的是一份源自字节跳动内部的数据结构刷题学习笔记，这份笔记在GitHub上引起广泛关注，被认为是一份有助于提升编程能力，尤其是对于准备字节跳动面试的程序员极具价值的资源。主要关注点在于各种排序...
刷题算法提高阶段-数据结构3
12-22
在"刷题算法提高阶段-数据结构3"这个主题中，我们主要关注的是通过实践来提升对数据结构的理解和应用能力，特别是针对解决特定问题时如何选择合适的数据结构。 数据结构，简单来说，是组织和存储数据的方式。它决定...
刷题算法提高阶段-数据结构7
12-22
在"刷题算法提高阶段-数据结构7"这个主题中，我们主要关注的是通过实践来提升对数据结构的理解和应用能力，特别是针对解决具体问题的能力。 数据结构，简单来说，就是组织和存储数据的方式。不同的数据结构适用于...
数据结构基本刷题
weixin_58850105的博客
03-06 1305
目录 1.两数的交集 2.买卖股票的最佳时期 3.合并两个数组 1.两数的交集 350. 两个数组的交集 II - 力扣（LeetCode） (leetcode-cn.com)https://leetcode-cn.com/problems/intersection-of-two-arrays-ii/ 题目及示例： 解题思路①：（利用集合来解决问题） ①将nums1中的数存入list1中 ②判断在nums2中的数是否在list1中存在，若存在，则将该数存入list2中 ...
3小时通关数据结构+实战刷题【图结构】
谢谢大家的关注
05-13 177
图结构在我们的生活中实际上是非常常见的，其中最显著的就是我们的地图了可以看到，地图盘根错节，错综复杂，不同的道路相互连接，我们可以自由地从这些道路通过，从一个地点到达另一个地点。当然除了地图，我们的计算机网络、你的人际关系网等等，这些都可以用图结构来表示。图结构也是整个数据结构中比较难的一部分，而这一章，我们将探讨图结构的性质与应用。
数据结构刷题合集
yyyyrr的博客
10-23 317
一P4113 [HEOI2012]采花 这是一个求一个区间出现次数大于等于二的数字的个数 这个的思路其实十分的的人类智慧，首先我们不难想到把所有的操作离线下来，之后就可以把复杂度降低了，之后就考虑一下如何去问维护信息，首先我们可以考虑前缀和，也就是参考HH的项链那道题，我们对于每一个color记录一下上一个出现的位置last1，之后假如再次出现就给上一个位置那里加一 这里不直接给第二次的位置加一是因为，考虑223这个序列，假如查询（2，3） ，就会出问题。 之后我们发现还有可能出现三次，这个假如像之前处理就
数据结构刷题笔记
m0_72379992的博客
01-21 1081
数据结构刷题笔记 一、绪论 通常从四个方面评价算法的质量：可读性、正确性、健壮性、高效性。 某算法时间复杂度为O(n*n)，说明算法执行时间与n *n成正比，其中n是问题规模 逻辑结构主要从数据元素之间的相邻关系考虑。用B=(D,R)表示，其中B表示一种逻辑数据结构，D是数据元素的集合，R是所有关系的集合 若某元素没有前驱节点，称其为开始元素，若没有后继节点，称其为终端元素 逻辑结构的类型：集合、线性结构、树形结构、图形结构 存储结构的类型：顺序存储结构、链式存储结构、索引存储结构、哈希（或散列）存储结构
考研数据结构刷题网站
08-21
有很多网站可以用来刷考研数据结构题目。其中，一些常见的网站包括leetcode、牛客网和PAT网。这些网站提供了大量的数据结构相关题目，可以帮助考研学生进行练习和提高。 在这些网站上，你可以找到各种类型的数据结构题目，包括链表、树、图、排序等等。你可以根据自己的需要选择适合的题目类型和难度级别来刷题。 刷题的目的可以有很多，比如为了备考考研的面试、为了参加程序设计竞赛、或者只是为了提高自己的算法能力。不同的目的可能需要选择不同的题目类型和难度级别。因此，在选择题目时，你可以根据自己的目标来进行筛选和练习。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [《数据结构知识点总结》计算机考研复试应届生求职刷题必备.pdf](https://download.csdn.net/download/liuning940307/31275197)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* *3* [刷了几千道算法题，这些我私藏的刷题网站都在这里了！](https://blog.csdn.net/u013486414/article/details/102961171)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小C您好

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值