数据结构刷题

已于 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
    评论
7天带你全方位刷爆数据结构与算法，每天一道，高效刷题
SQY0809的博客
06-09 454
很多算法小白初期刷题比较迷茫，不知道从何刷起从何入手，也不知道怎么使用LeetCode，这篇带你高效使用力扣，让刷题进大厂的路上不再迷茫！
数据结构刷题记录
weixin_45484128的博客
03-12 174
分支限界法与回溯法求解目标不同 : 回溯法的求解目标是找出解空间中满足约束条件的所有解，而分支限界法的求解目标是找出满足约束条件的一个解，或者是在满足约束条件的解中找出使某一个目标函数值达到极大或者极小的解，即某种意义下的最优解 搜索方式不同 : 回溯法以深度优先搜索的方式进行搜索，而分支限界法使用广度优先搜索或者最小耗费优先的方式进行搜索解空间，其策略是 : 在扩展结点处，先生成其所有的儿子结点(分支)， 然后从当前的活结点表中选择下一个扩展结点。计算一个函数值(限界) : 为了加速搜索的过程，在每一个活
大厂算法和数据结构刷题
07-28
大厂算法和数据结构刷题java实现
数据结构刷题总结
loveyourz1的博客
05-03 551
将字符串 “abc” 插入到 t 中的任意位置。形式上，t 变为 tleft + “abc” + tright，其中 t == tleft + tright。注意，tleft 和 tright 可能为 空。栈善于处理消消乐这类配对问题。并且可以同时string和queue来模拟栈。如果字符串 s 有效，则返回 true；否则，返回 false。给你一个字符串 s ，请你判断它是否 有效。
数据结构与算法【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
如果可以，写出这个递归函数的定义，并充分利用这个函数的返回值。
数据结构刷题合集
yyyyrr的博客
10-23 317
一P4113 [HEOI2012]采花 这是一个求一个区间出现次数大于等于二的数字的个数 这个的思路其实十分的的人类智慧，首先我们不难想到把所有的操作离线下来，之后就可以把复杂度降低了，之后就考虑一下如何去问维护信息，首先我们可以考虑前缀和，也就是参考HH的项链那道题，我们对于每一个color记录一下上一个出现的位置last1，之后假如再次出现就给上一个位置那里加一 这里不直接给第二次的位置加一是因为，考虑223这个序列，假如查询（2，3） ，就会出问题。 之后我们发现还有可能出现三次，这个假如像之前处理就
大厂算法和数据结构刷题班.zip
01-01
"大厂算法和数据结构刷题班.zip"很可能是为准备这类挑战而设计的学习资料，包含了针对这些公司面试的算法和数据结构训练题目。 数据结构主要包括数组、链表、栈、队列、哈希表、树（二叉树、平衡树、堆）、图等。每...
蓝桥杯真题解析，常用算法和数据结构刷题
最新发布
01-23
蓝桥杯真题解析，常用算法和数据结构刷题，RAS解密，等差数列，迷宫，方格分割等等 蓝桥杯真题解析，常用算法和数据结构刷题，RAS解密，等差数列，迷宫，方格分割等等 蓝桥杯真题解析，常用算法和数据结构刷题，RAS...
数据结构基本刷题
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
图结构在我们的生活中实际上是非常常见的，其中最显著的就是我们的地图了可以看到，地图盘根错节，错综复杂，不同的道路相互连接，我们可以自由地从这些道路通过，从一个地点到达另一个地点。当然除了地图，我们的计算机网络、你的人际关系网等等，这些都可以用图结构来表示。图结构也是整个数据结构中比较难的一部分，而这一章，我们将探讨图结构的性质与应用。
数据结构刷题笔记
m0_72379992的博客
01-21 1081
数据结构刷题笔记 一、绪论 通常从四个方面评价算法的质量：可读性、正确性、健壮性、高效性。 某算法时间复杂度为O(n*n)，说明算法执行时间与n *n成正比，其中n是问题规模 逻辑结构主要从数据元素之间的相邻关系考虑。用B=(D,R)表示，其中B表示一种逻辑数据结构，D是数据元素的集合，R是所有关系的集合 若某元素没有前驱节点，称其为开始元素，若没有后继节点，称其为终端元素 逻辑结构的类型：集合、线性结构、树形结构、图形结构 存储结构的类型：顺序存储结构、链式存储结构、索引存储结构、哈希（或散列）存储结构
数据结构刷题（一）
qq_53893431的博客
03-07 269
题目链接 方法一：迭代 struct ListNode* removeElements(struct ListNode* head, int val) { if(head==NULL) return head; head->next=removeElements(head->next,val); return head->val==val?head->next:head; } 方法二：遍历 struct ListNode* r..
力扣之数据结构基础的刷题总结
小黑同学的博客
05-21 966
内容 一、数组总结 1、vector数组 2、构造哈希表---数组里面存LIST 二、字符串总结 1、int与char的转换 2、字符串相加 3、字符串相乘-----大数运算 4、快速抽出以空格为间隔的字符串--学会抽子字符串 5、删除字符串的当前字符 6、在字符串加入字符串 7、字符串和数字的转换 三、链表总结 1、对于入门阶段的题目就出现过的“环形链表” 2、相交链表 3、删除链表的重复元素 4、两两交换链表的节点 5、重排链表---寻找链表中点 + 链表逆序 + 合并链表 6、K个一组翻转链表 ...
数据结构期末刷题
qq_45418837的博客
11-28 1812
数据结构期末刷题
数据结构100题 刷题记录 Python
yayaduan的博客
08-19 829
25天，到9.25号 做完100题 Python 数据结构 100题 好多思想总结不是很清晰，希望有Uu一起做题一起讨论
【数据结构刷题篇】链表篇
qq_54883034的博客
01-11 810
文章目录1.将单链表按值划分为链表左边小，中间相等，右边大的结构思路1.0荷兰国旗问题思路2.02.复制含有任意指针指向的链表思路1.0思路2.03.两个单链表相交的一系列问题1.子问题一：2.子问题二：3.子问题三：4.链表中的数字相加1.题目1.02.题目2.05.反转链表II 1.将单链表按值划分为链表左边小，中间相等，右边大的结构 题目分析：简单的来说就是把链表中的节点按照题目中给定话划分值target，给隔开，小于target的节点串到一块，等于target的节点串到一块，大于target的链表节
刷题总结——数据结构基础
margaret522的博客
03-06 385
2022/3/6 1.leetcode136只出现一次的数字。 位运算。注意异或运算三个性质。 异或运算有以下三个性质。 任何数和 000 做异或运算，结果仍然是原来的数，即 a⊕0=a。 任何数和其自身做异或运算，结果是 000，即 a⊕a=0。 异或运算满足交换律和结合律，即 a⊕b⊕a=b⊕a⊕a=b⊕(a⊕a)=b⊕0=b。 2.leetcode169多数元素。 注意排序法。 ...
考研数据结构刷题网站
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、付费专栏及课程。

余额充值