牛马学习数据结构 第六天

已于 2024-05-08 12:01:04 修改
阅读量456 收藏 6
点赞数 8
文章标签： 数据结构 学习 算法
于 2024-03-28 17:36:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lu_time/article/details/137033376
版权

1、超级楼梯（典型斐波那契数列）

Problem Description

有一楼梯共M级，刚开始时你在第一级，若每次只能跨上一级或二级，要走上第M级，共有多少种走法？

Input

输入数据首先包含一个整数N，表示测试实例的个数，然后是N行数据，每行包含一个整数M（1<=M<=40）,表示楼梯的级数。

Output

对于每个测试实例，请输出不同走法的数量

Sample Input

2 2 3

Sample Output

1 2

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

#define eleType int

typedef struct ListNode{
	eleType data;
	struct ListNode *next;
}ListNode;

typedef struct LinkList{
	struct ListNode *head;
	size_t size;
}LinkList;
//初始化链表 
void LinkListInit(LinkList *list){
	list->head=NULL;
	list->size=0;
}
//删除链表 
void LinkListDelete(LinkList *list){
	while(list->head){
		ListNode *temp=list->head;
		list->head=list->head->next;
		free(temp);
	}
	list->size=0; 
}
//插入 
void LinkListInsert(LinkList *list,int index,eleType value){
	if(index<0||index>list->size){
		printf("Invalid Index");
		return ;
	}
	ListNode *NewNode=(ListNode*)malloc(sizeof(eleType));
	NewNode->data=value;
	if(index==0){
		NewNode->next=list->head;
		list->head=NewNode;
	}
	else{
		ListNode *couret=list->head;
		for(int i=0;i<index-1;++i){
			couret=couret->next;
		}
		NewNode->next=couret->next;
		couret->next=NewNode;
	}
	list->size++;
}
//删除某个元素 
void LinkListRemov(LinkList *list,int index){
		if(index<0||index>=list->size){
		printf("Invalid Index");
		return ;
	}
	if(index==0){
		ListNode *couret=list->head;
		couret->next=list->head->next;
		free(list->head);
		list->head=couret; 
	}
	else{
		ListNode *couret=list->head;
		for(int i=0;i<index-1;++i){
			couret=couret->next;
		}
		ListNode *next=couret->next->next;
		free(couret->next);
		couret->next=next;
	}
	list->size--;
}
//查找 
ListNode *LinkListFind(LinkList *list,eleType value){
	ListNode *couret=list->head;
	while(couret){
		if(couret->data==value){
			return couret;
		}
		couret=couret->next;
	}
	return NULL;
} 
//索引 
ListNode *LinkListGet(LinkList *list,int index){
	if(index<0||index>=list->size){
	printf("Invalid Index");
	return NULL;
	}
	ListNode *couret=list->head;
	for(int i=0;i<index;++i){
		couret=couret->next;
	}
	return couret;
} 

void LinkListUpdata(LinkList *list,int index,eleType value){
	ListNode *nod=LinkListGet(list,index);
	if(nod){
		nod->data=value;
	}
}

void LinkListPrintf(LinkList *list){
	ListNode *couret=list->head;
	while(couret){
		printf("%d ->",couret->data);
		couret=couret->next;
	}
	printf("NULL\n");
}
/*
斐波那契数列 
0 1 1 2 3 5 8 13....
i ->data=(i-1)->data + (i-2)->data
*/
int main(){
	LinkList list;
	LinkListInit(&list);
	LinkListInsert(&list,0,0);
	LinkListInsert(&list,1,1);
	for(int i=2;i<40;++i){
		int i_1=LinkListGet(&list,i-1)->data;
		int i_2=LinkListGet(&list,i-2)->data;
		LinkListInsert(&list,i,i_1+i_2);
	}
	int n;
	scanf("%d",&n);
	while(n--){
		int m;
		scanf("%d",&m);
		printf("%d\n",LinkListGet(&list,m)->data);
	}
	LinkListDelete(&list);
	return 0;
}

 2、数列有序

需要稍加修改一下输出函数

Problem Description

有n(n<=100)个整数，已经按照从小到大顺序排列好，现在另外给一个整数x，请将该数插入到序列中，并使新的序列仍然有序。

Input

输入数据包含多个测试实例，每组数据由两行组成，第一行是n和m，第二行是已经有序的n个数的数列。n和m同时为0标示输入数据的结束，本行不做处理。

Output

对于每个测试实例，输出插入新的元素后的数列。

Sample Input

3 3 1 2 4 0 0

Sample Output

1 2 3 4

void LinkListPrintf(LinkList *list){
	ListNode *couret=list->head;
	while(couret){
		printf("%d ",couret->data);
		couret=couret->next;
	}
	printf("\n");
}

int main(){
	int n,m;
	while(scanf("%d %d",&n,&m)!=EOF && n!=0 && m!=0){
		LinkList list;
		LinkListInit(&list);
		int x;
		for(int i=0;i<n;++i){
			scanf("%d",&x);
			LinkListInsert(&list,i,x);
		}
		ListNode *node=list.head;
		int pos=0;
		for(int i=0;i<n;++i){
			if(node->data>m){
				break;
			}
			node=node->next;
			pos++;
		}
		LinkListInsert(&list,pos,m);
		LinkListPrintf(&list);
		LinkListDelete(&list);
	}
	return 0;
}

 3、二进制链表转整数

（在链表中存储二进制的方法是从低地址开始存储的就是   0 --> i-1 个位置，而二进制是从右往左是逐渐增大的，比如 链表 0-->i-1 [10110] ,二进制 n<--1[ 01101]）

给你一个单链表的引用结点 head。链表中每个结点的值不是 0 就是 1。已知此链表是一个整数数字的二进制表示形式。

请你返回该链表所表示数字的 十进制值 。

示例 1：

输入：head = [1,0,1]
输出：5
解释：二进制数 (101) 转化为十进制数 (5)

示例 2：

输入：head = [0]
输出：0

示例 3：

输入：head = [1]
输出：1

示例 4：

输入：head = [1,0,0,1,0,0,1,1,1,0,0,0,0,0,0]
输出：18880

示例 5：

输入：head = [0,0]
输出：0
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
int getDecimalValue(struct ListNode* head) {
    int sum=0;
    while(head){
        sum=sum*2+head->val;
        head=head->next;
    }
    return sum;  
}

4、返回倒数第K个节点 （快慢指针的应用）

实现一种算法，找出单向链表中倒数第 k 个节点。返回该节点的值。

示例：

输入： 1->2->3->4->5 和 k = 2
输出： 4
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


int kthToLast(struct ListNode* head, int k){
    struct ListNode *fast =head;
    while(k--){
        fast=fast->next;
    }
    struct ListNode *slow =head;
    while(fast){
        fast=fast->next;
        slow=slow->next;
    }
    return slow->val;
}

5、训练计划

给定一个头节点为 head 的链表用于记录一系列核心肌群训练项目编号，请查找并返回倒数第 cnt 个训练项目编号。

示例 1：

输入：head = [2,4,7,8], cnt = 1
输出：8
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* trainingPlan(struct ListNode* head, int cnt) {
    struct ListNode *fast=head;
    while(cnt--){
        fast=fast->next;
    }
    struct ListNode *slow=head;
    while(fast){
        fast=fast->next;
        slow=slow->next;
    }
    return slow;
}

6、删除中间节点 

若链表中的某个节点，既不是链表头节点，也不是链表尾节点，则称其为该链表的「中间节点」。

假定已知链表的某一个中间节点，请实现一种算法，将该节点从链表中删除。

例如，传入节点 c（位于单向链表 a->b->c->d->e->f 中），将其删除后，剩余链表为 a->b->d->e->f

示例：

输入：节点 5 （位于单向链表 4->5->1->9 中）
输出：不返回任何数据，从链表中删除传入的节点 5，使链表变为 4->1->9
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
void deleteNode(struct ListNode* node) {
    struct ListNode *fast=node->next;
    if(fast){
        node->val=fast->val;
        node->next=fast->next;  
        free(fast);
    }
}

7、移除链表中的元素

 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

示例 2：

输入：head = [], val = 1
输出：[]

示例 3：

输入：head = [7,7,7,7], val = 7
输出：[]

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeElements(struct ListNode* head, int val) {
    struct ListNode *temp;
    while(head && head->val == val){
        temp=head;
        head=head->next;
        free(temp);
    }
    struct ListNode *crut=head;
    while(crut && (temp=crut->next)){
        if(temp->val==val){
            crut->next=crut->next->next;
            free(temp);
        }else{
            crut=crut->next;
        }
    }
    return head;
}

8、删除链表中的节点

有一个单链表的 head，我们想删除它其中的一个节点 node。

给你一个需要删除的节点 node 。你将 无法访问 第一个节点  head。

链表的所有值都是 唯一的，并且保证给定的节点 node 不是链表中的最后一个节点。

删除给定的节点。注意，删除节点并不是指从内存中删除它。这里的意思是：

  • 给定节点的值不应该存在于链表中。
  • 链表中的节点数应该减少 1。
  • node 前面的所有值顺序相同。
  • node 后面的所有值顺序相同。

自定义测试：

  • 对于输入，你应该提供整个链表 head 和要给出的节点 node。node 不应该是链表的最后一个节点，而应该是链表中的一个实际节点。
  • 我们将构建链表，并将节点传递给你的函数。
  • 输出将是调用你函数后的整个链表。

示例 1：

输入：head = [4,5,1,9], node = 5
输出：[4,1,9]
解释：指定链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9

示例 2：

输入：head = [4,5,1,9], node = 1
输出：[4,5,9]
解释：指定链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
void deleteNode(struct ListNode* node) {
    node->val=node->next->val;
    node->next=node->next->next;
}

 9、删除排序链表中重复的元素

给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。

示例 1：

输入：head = [1,1,2]
输出：[1,2]

示例 2：

输入：head = [1,1,2,3,3]
输出：[1,2,3]
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* deleteDuplicates(struct ListNode* head) {
    if(!head){
        return head;
    }
    struct ListNode *temp;
    struct ListNode *crut=head;
    while(crut && (temp=crut->next)){
        if(crut->val==temp->val){
  //          crut->val=crut->next->val;
            crut->next=crut->next->next;
            free(temp);
        }else{
            crut=crut->next;
        }
    }
    return head;
}

Lu_time
关注
牛马学习数据结构第四天
Lu_time的博客
03-18 791
例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。孩子 1 有 2 个糖果，如果他得到所有额外的糖果（3个），那么他总共有 5 个糖果，他将成为拥有最多糖果的孩子。孩子 4 有 1 个糖果，即使他得到所有额外的糖果，他也只有 4 个糖果，无法成为拥有糖果最多的孩子。孩子 2 有 3 个糖果，如果他得到至少 2 个额外糖果，那么他将成为拥有最多糖果的孩子。元素的顺序可以改变。孩子 3 有 5 个糖果，他已经是拥有最多糖果的孩子。
牛马学习数据结构：第二天
Lu_time的博客
02-15 411
一：利用数据结构顺序表的曾删改查实现：青年歌手大奖赛_评委会打分。
牛马学习数据结构第三天
Lu_time的博客
03-16 294
解释：第一堆力扣币最少需要拿 2 次，第二堆最少需要拿 1 次，第三堆最少需要拿 1 次，总共 4 次即可拿完。开头的两位和最后的三位都是连续 1 ，所以最大连续 1 的个数是 3.nums 的数字和是 1 + 1 + 5 + 6 + 3 = 16。nums 的元素和是 1 + 15 + 6 + 3 = 25。nums 的元素和是 1 + 2 + 3 + 4 = 10。nums 的数字和是 1 + 2 + 3 + 4 = 10。元素和与数字和的绝对差是 |10 - 10| = 0。
牛马学习数据结构 第七天
Lu_time的博客
03-31 376
书店店员有一张链表形式的书单，每个节点代表一本书，节点中的值表示书的编号。为更方便整理书架，店员需要将书单倒过来排列，就可以从最后一本书开始整理，逐一将书放回到书架上。请倒序返回这个书单链表。的单链表用于记录一系列核心肌群训练编号，请将该系列训练编号。编写代码，移除未排序链表中的重复节点。保留最开始出现的节点。，请反转链表，并返回反转后的链表的头节点。
数据结构与算法——栈
2301_80888963的博客
10-05 981
栈
数据结构与算法——线性表的顺序存储
2301_80888963的博客
09-22 1209
Linear_list=(D,R)，其中D={ai|ai∈A,i=1,2,…n;关系的定义<ai,ai+1>：ai,ai+1必定相邻；ai必定在ai+1之前（如果i+1存在）
数据结构之链表详解
weixin_68624665的博客
03-12 581
即顺序表之后，今天给大家带来另外一个线性结构——链表。
数据结构之顺序表详解
weixin_68624665的博客
03-11 276
今天给大家带来的是数据结构的顺序表结构，以及与其的有关功能的实现，在数据结构的这部分内容，可能有些知识点有点难以理解，这里小编会配合图画，让大家能够更好的理解，那么下面就让我们直接步入正题吧。
2022BUAA数据结构期末大作业的一些想法
m0_62558898的博客
07-01 3447
本文写的内容可能在很多巨佬看来属实是一些简单的废话，但我的底子比较薄，很多东西都是想了好久，这篇文章的主要目的实际上也只不过是把我的一些改进的地方记录下来，防止以后忘记。。。...
牛马.zip
01-17
这本第六版的书籍详细介绍了C语言的基础概念、语法以及高级特性，旨在帮助初学者和有一定经验的程序员深入理解和掌握C语言。 1. **C语言基础**：C语言是一种通用的、结构化的编程语言，它以其高效、灵活和可移植性...
牛马抽奖(1).zipPHP项目程序网站源码下载
03-05
8. API集成：如果项目涉及与其他系统交互，如发送短信验证码、第三方支付接口，你可以学习API调用的方法，理解HTTP请求、JSON格式数据的处理。 9. 测试与调试：在项目开发完成后，测试是必不可少的环节。你可以了解...
第一章 数据清洗概述
qq_46602903的博客
09-12 1399
前言 近年来，大数据技术掀起了计算机领域的一个新浪潮，无论是数据挖掘、数据分析、数据可视化，还是机器学习、人工智能，它们都绕不开“数据”这个主题。 由于海量数据的来源是广泛的，数据类型也是多而繁杂的，因此数据中会夹杂着不完整、重复以及错误的数据，如果直接使用这些原始数据，会严重影响数据决策的准确性和效率。因此，对原始数据进行有效的清洗是大数据分析和应用过程中的关键环节。 1、数据清洗的背景 当今时代，企业信息化的要求越来越迫切。对于企业的决策者来说，正所谓“垃圾进垃圾出( garbage in, g
恒源云(GPUSHARE)_[SimCSE]：对比学习，只需要 Dropout?
weixin_53977063的博客
12-29 681
文章来源 | 恒源云社区(恒源云，专注 AI 行业的共享算力平台) 原文地址 | Dropout 原文作者 | Mathor 要说2021年上半年NLP最火的论文，想必非《SimCSE: Simple Contrastive Learning of Sentence Embeddings》莫属。SimCSE的全称是Simple Contrastive Sentence Embedding Sentence Embedding Sentence Embedding一直是NLP领域的一个热门问题，主要是因为其
C# 中 List、ArrayList 和数组的区别
m0_60315436的博客
10-10 869
C# 中的数组、ArrayList 和 List 在存储方式、功能特性和适用场景上存在着明显的区别。数组具有固定大小和类型安全的特点，适用于已知固定数量的元素和对性能要求极高的场景；ArrayList 具有动态大小和弱类型的特点，适用于存储不同类型的元素和对集合大小不确定的情况；List 具有强类型和泛型支持、高效性能和丰富功能的特点，适用于类型安全要求高和性能与灵活性兼顾的场景。在实际编程中，程序员应根据具体的需求选择合适的数据结构，以提高程序的效率和质量。
80.【C语言】数据结构之时间复杂度
2401_85828611的博客
10-12 987
参见63.【C语言】再议结构体(上)也可以理解为数据在内存中的存储形式(管理数据)比如说写通讯录可以用静态数组,动态数组和链表形式存储简单的定义:一系列的计算步骤，用来将输入数据转化成输出结果若次数为常数,时间复杂度为若次数为N的表达式1.取最高阶的式子(去常数) 2.去掉最高阶式子前的系数若存在最好,最坏情况,取最坏的情况作为时间复杂度。
数据结构-排序1
2401_83575662的博客
10-08 1016
排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次 序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排 序算法是稳定的；否则称为不稳定的。内部排序：数据元素全部放在内存中的排序。外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不断地在内外存之间移动数据的排序。
数据结构：栈的创建、使用以及销毁
最新发布
qq_71391318的博客
10-13 829
栈的创建销毁
数据结构-5.5.二叉树的存储结构
ADCvbV的博客
10-12 673
(i是结点编号)1.上述图片中i所在的层次后面的公式应该把n换成i(图片里写错了)；2.上述图片判断i是否有左孩子，只需要判断是否2i<=n（2i代表第i个结点的左孩子，n代表完全二叉树的结点总数），如果2i<=n，就说明有左孩子，如果2i>n，说明没有左孩子(思路：把i当作是最后一个结点，此时i等于n，如果i有左孩子即2i，那么2i就大于n，此时结点总数为2i，显然不等于n，说明没有左孩子)，判断i是否有右孩子同理；3.上述图片判断i是否是叶子/分支结点，只需要判断是否i>[n/2] (这里是对n/2向下
嵌入式数据结构中线性表的具体实现
嵌入式技术开发
10-10 527
线性表的定义 – 线性表就是零个或多个相同数据元素的有限序列。• 线性表的表示方法 – 线性表记为： L=(a0,∙∙∙∙∙∙∙∙ai-1aiai+1 ∙∙∙∙∙∙an-1)• 其中：L为表名，ai (0≤i≤n-1)为数据元素；• n为表长,n>0 时，线性表L为非空表，否则为空表，记为φ；。
java常考的数据结构？
12-08
Java常考的数据结构包括线性表、栈、队列、树、图等。以下是一些常见的数据结构及其Java实现示例： 1. 线性表 线性表是一种数据结构，其中数据元素按线性顺序排列，每个数据元素最多有一个前驱和一个后继。常见的线性表包括数组和链表。 ```java // 数组实现线性表 int[] arr = new int[]{1, 2, 3, 4, 5}; for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } // 链表实现线性表 class ListNode { int val; ListNode next; ListNode(int x) { val = x; } } ListNode head = new ListNode(1); head.next = new ListNode(2); head.next.next = new ListNode(3); while (head != null) { System.out.println(head.val); head = head.next; } ``` 2. 栈 栈是一种后进先出（LIFO）的数据结构，常用于表达式求值、括号匹配等场景。 ```java // 栈的实现 Stack<Integer> stack = new Stack<>(); stack.push(1); stack.push(2); stack.push(3); while (!stack.isEmpty()) { System.out.println(stack.pop()); } ``` 3. 队列 队列是一种先进先出（FIFO）的数据结构，常用于广度优先搜索等场景。 ```java // 队列的实现 Queue<Integer> queue = new LinkedList<>(); queue.offer(1); queue.offer(2); queue.offer(3); while (!queue.isEmpty()) { System.out.println(queue.poll()); } ``` 4. 树 树是一种非线性数据结构，由节点和边组成，每个节点最多有一个父节点和多个子节点。常见的树包括二叉树、二叉搜索树、堆等。 ```java // 二叉树的实现 class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } TreeNode root = new TreeNode(1); root.left = new TreeNode(2); root.right = new TreeNode(3); ``` 5. 图 图是一种非线性数据结构，由节点和边组成，每个节点可以有多个相邻节点。常见的图包括有向图、无向图、加权图等。 ```java // 有向图的实现 Map<Integer, List<Integer>> graph = new HashMap<>(); graph.put(0, Arrays.asList(1, 2)); graph.put(1, Arrays.asList(2)); graph.put(2, Arrays.asList(0, 3)); graph.put(3, Arrays.asList(3)); ```
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值