C++修改文件后缀名；链表循环删除乘积为10的元素

已于 2024-06-01 00:04:40 修改
阅读量525 收藏 5
点赞数 6
分类专栏： 语言学习 文章标签： c++ 排序算法 开发语言
于 2024-05-29 22:14:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36914923/article/details/139307046
版权

1. 文件名修改

在一个文件目录下，存在相同扩展名 ".stp"的多个文件，对这样的文件名，请修改文件名称，在文件 名称后增加排序标识 "-01" ， "-02" ， "-03"... 
#include <iostream>
#include <io.h>
#include <fstream>
#include <string>
#include <vector>
using namespace std;

// Input： 目录名称
// Output：文件列表清单

class Findupdate {
public:
    void replaceFileNameList();//遍历文件列表替换文件名
    bool checkFile(string path);//查找路径下所有文件，不存在子文件夹
    bool checkFile_circ(string path, vector<string>& m_vec_file_path_name);//查找路径下所有文件，存在子文件夹

    ~Findupdate()
    {
        m_vec_file_path_name.clear();
    }
    vector<string> m_vec_file_path_name; //文件名路径列表
private:
    bool replaceFileName(string oldFileName, string newFileName);//替换文件名 
    string m_modif_before = ".stp";             //指定修改前的字段
};

bool Findupdate::replaceFileName(string oldFileName, string newFileName)
{
    fstream fs;
    fs.open(oldFileName.c_str());
    if (fs.fail())
    {
        cout << "文件打开失败！" << endl;
        fs.close();
        return false;
    }
    else
    {
        fs.close();
        if (rename(oldFileName.c_str(), newFileName.c_str()) == -1)   //文件重命名
        {
            cout << "文件名修改失败！" << endl;
            return false;
        }
        return true;
    }
    return true;
}

void Findupdate::replaceFileNameList()
{
    int num = 1;
    string ModifyAfterFilds = "";                  //指定修改后的字段
    for (auto name : m_vec_file_path_name)
    {
        //临时文件名用于字符替换
        string newFileName = name;
        int findIndex = name.find(m_modif_before, 1);
        if (findIndex != -1 && findIndex == (name.size()-4))
        {
            ModifyAfterFilds = ".stp-0" + std::to_string(num); 
            num++;
            newFileName = newFileName.replace(findIndex, m_modif_before.size(), ModifyAfterFilds);
            cout << name << endl;
            cout << newFileName << endl;
        }
        else
        {
            continue;
        }        
        int ret = replaceFileName(name, newFileName);
    }
}

bool Findupdate::checkFile(string path)
{
	string EachPath = path;      //临时路径，用于字符拼接
	intptr_t FileHandle;             //文件句柄
	struct _finddata_t FileInfo;     //文件信息

	if ((FileHandle = _findfirst(EachPath.append("\\*").c_str(), &FileInfo)) == -1)
	{
		cout << "未找到文件! " << endl;
		return false;
	}
	else
	{
		while (_findnext(FileHandle, &FileInfo) == 0)
		{
			if (strcmp(FileInfo.name, ".") != 0 && strcmp(FileInfo.name, "..") != 0)
			{
				m_vec_file_path_name.push_back(FileInfo.name);
				cout << "FileName : " << FileInfo.name << endl;
			}
		}
		_findclose(FileHandle);
	}
	return true;
}

bool Findupdate::checkFile_circ(string path, vector<string>& m_vec_file_path_name)
{
	string EachPath = path;      //临时路径，用于字符拼接
	intptr_t FileHandle;             //文件句柄
	struct _finddata_t FileInfo;     //文件信息

	//使用_findfirst查找文件，获取文件信息
	if ((FileHandle = _findfirst(EachPath.append("\\*").c_str(), &FileInfo)) == -1)
	{
		cout << "failed find file! " << endl;
		return false;
	}
	else
	{
		do
		{   // 比较文件类型是否是文件夹
			if ((FileInfo.attrib &  _A_SUBDIR))
			{
				if (strcmp(FileInfo.name, ".") != 0 && strcmp(FileInfo.name, "..") != 0)
				{
					EachPath = path;   //每次从根路径拼接
					//递归调用
					checkFile_circ(EachPath.append("\\").append(FileInfo.name), m_vec_file_path_name);
				}
			}
			else
			{
				EachPath = path;
				m_vec_file_path_name.push_back(EachPath.append("\\").append(FileInfo.name));

				cout << "PATH/FileName : " << EachPath << endl;
			}
		} while (_findnext(FileHandle, &FileInfo) == 0);
		_findclose(FileHandle);
	}
	return true;
}

int main()
{
	string Path = "E:\\xx\\xx";      //自定义路径
    Findupdate f_upate;
	
  //  f_upate.checkFile(Path); //路径下没有子文件夹
    f_upate.checkFile_circ(Path, f_upate.m_vec_file_path_name);
    f_upate.replaceFileNameList();

	system("pause");
	return 0;
}


 

2.链表删除

链表 head ， 反复 删去链表中由 总乘积 值为 10 的连续节点组成的序列， 直到不存在这样的序列为止，需 考虑各种特殊情况。 
#include<iostream>
using namespace std;

struct ListNode {  
    int val;  
    ListNode *next;  
    ListNode(int x) : val(x), next(NULL) {}  
};  

class Solution
{
public:
    // 辅助函数：打印链表  
    void printList(ListNode* head) {  
        while (head) {  
            std::cout << head->val << " ";  
            head = head->next;  
        }  
        std::cout << std::endl;  
    }  
    
    // 辅助函数：创建链表  
    ListNode* createList(int arr[], int n) {  
        if (n == 0) return nullptr;  
        ListNode* head = new ListNode(arr[0]);  
        ListNode* curr = head;  
        for (int i = 1; i < n; ++i) {  
            curr->next = new ListNode(arr[i]);  
            curr = curr->next;  
        }  
        return head;  
    }  
    
    // 辅助函数：释放链表内存  
    void deleteList(ListNode* head) {  
        while (head) {  
            ListNode* temp = head;  
            head = head->next;  
            delete temp;  
        }  
    }  

    ListNode* removeSublists(ListNode* head)
    {
        // 创建一个哑节点作为头节点的前驱  
        ListNode dummy(0);  
        dummy.next = head;  
        ListNode* prev = &dummy;  
        ListNode* curr = head;  
    
        while (curr && curr->next) {  
            // 检查当前节点和下一个节点的乘积是否为10  
            while (curr && curr->next && curr->val * curr->next->val == 10) {  
                // 删除这两个节点  
                prev->next = curr->next->next;  
                // 移动到下一个要检查的节点（注意这里不是curr = prev->next，因为prev->next可能已经被改变了）  
                curr = curr->next;
            }  
            curr = prev->next;  
            // 如果没有找到乘积为10的节点对，则移动到下一个要检查的节点对  
            if (curr) {  
                prev = curr;  
                curr = curr->next;  
            }  
        }  
    
        // 返回哑节点的下一个节点作为新的头节点  
        return dummy.next; 
    }
};
  
int main() {  
    int arr[] = {1, 2, 5, 2, 1, 2, 5}; // 示例链表：1 -> 2 -> 5 -> 2 -> 1 -> 2 -> 5  

    Solution sol_list;
    ListNode* head = sol_list.createList(arr, sizeof(arr) / sizeof(arr[0]));
    std::cout << "Original List: ";  
    sol_list.printList(head);
    head = sol_list.removeSublists(head);  
    std::cout << "List after removing product-ten nodes: ";  
    sol_list.printList(head);  
  
    sol_list.deleteList(head); // 释放链表内存  
    return 0;  
}

上面的解决的范围不全

2024.5.31

修改链表重复删除乘积为10的连续节点。考虑两种特殊情况，情况1，被删除的节点，可能与后面的节点重新形成乘积为10的连续节点，这种都会删除 （相当于区间覆盖，增加了数组的区间范围输出的函数，利用滑动窗口思路来解）；情况2 当前链表被删除后，可能会出现，新的乘积为10的连续节点，这种情况，继续删除，如，2,2,5,5，中间，2,5删除后剩下的2,5 还可以被删除。

struct ListNode {  
    int val;  
    ListNode *next;  
    ListNode(int x) : val(x), next(NULL) {}  
};  

class Solution
{
public:
    // 辅助函数：打印链表  
    void printList(ListNode* head) {  
        while (head) {  
            std::cout << head->val << " ";  
            head = head->next;  
        }  
        std::cout << std::endl;  
    }  
    
    // 辅助函数：创建链表  
    ListNode* createList(int arr[], int n) {  
        if (n == 0) return nullptr;  
        ListNode* head = new ListNode(arr[0]);  
        ListNode* curr = head;  
        for (int i = 1; i < n; ++i) {  
            curr->next = new ListNode(arr[i]);  
            curr = curr->next;  
        }  
        return head;  
    }  
    
    // 辅助函数：释放链表内存  
    void deleteList(ListNode* head) {  
        while (head) {  
            ListNode* temp = head;  
            head = head->next;  
            delete temp;  
        }  
    }  

    bool check(ListNode* head)
    {
       // 创建一个哑节点作为头节点的前驱  
        ListNode dummy(0);  
        dummy.next = head;
        ListNode* prev = head;
        ListNode* cur = head;
        int prod = 1;
        while(cur)
        {
            prod*= cur->val;
            while(prev != cur && abs(prod) > 10)
            {
                prod /= prev->val;
                prev = prev->next;
            }
            if(prod == 10)
            {
                return true;
            }
            cur = cur->next;
        }
        return false; 
    }
    //利用滑动窗口模型，采用双指针，找到需要删除的范围
    //范围可能出现交叉或者覆盖，暂时用map 保存每个节点指针，方便后期删除
    ListNode* removeSublists(ListNode* head)
    {
        ListNode dummy(0);  
        dummy.next = head;
        ListNode* prev = head;
        ListNode* cur = head;
        map<ListNode*, int> m_p;
        int prod = 1;
        while(cur)
        {
            prod*= cur->val;
            while(prev != cur && abs(prod) > 10)
            {
                prod /= prev->val;
                prev = prev->next;
            }
            if(prod == 10)
            {
                ListNode* tp = prev;
                while(tp != cur)
                {
                   m_p[tp] = tp->val;
                   tp = tp->next;
                }
                m_p[cur] = cur->val;
            }
            cur = cur->next;
        }
        ListNode* p_r = &dummy;//最终需要删除的指针
        ListNode* p_rp = head;//遍历
        while(p_rp)
        {
            if(m_p.count(p_rp) == 0)
            {   
                p_r->next = p_rp;
                p_r = p_r->next;
            }
            p_rp = p_rp->next;
        }
        p_r->next = p_rp;
        map<ListNode*, int>().swap(m_p);
        return dummy.next;
    }

    void fun(int* nums, int numsSize)
    {//测试数组中符合的乘积，输出范围
        //滑动窗口数数组模型
        int ret = 0;
        int prod = 1, i = 0;
        for (int j = 0; j < numsSize; j++) {
            prod *= nums[j];
            while (i <= j && abs(prod) > 10) {
                prod /= nums[i];
                i++;
            }
            //cout << prod << endl;
            if(prod == 10){
                cout <<"范围： " << i << " " << j <<";";
            }
        }
    }

};

3. VS Code 配置 gitee

在VScode上配置Git - 知乎

Gitee 源码

坤坤爱技术~
关注
  • 6
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法题目及C++解答
Ankang的博客
06-03 1万+
前言 题目主要按照类型进行整理，包括leetcode，nowcoder等网站，对于可以使用多种方法的题目，不重复列举。推荐书籍《数据结构与算法分析--C++语言描述》第四版。 本文中所有源代码及博客中其他文章的VS源代码均在github：https://github.com/AnkangH，根据名称检索即可。 1.排序算法 SortAlgorithm 排序算法的源码见博客内排序算法的文章。...
用C++实现的循环链表
04-15
循环链表是一种特殊的链式存储结构，与普通链表的主要区别在于它最后一个节点的指针并不指向NULL，而是指回链表的第一个元素，形成了一个闭合的循环。这种结构使得链表的遍历更为便捷，尤其在处理需要“首尾相连”的...
leetcode刷题记录三
oooooorz的博客
04-29 179
多是一些带有技巧的问题，比如双指针，常拿来判定链表是否有环、寻找特殊点、寻找两个链表的焦点等。
C++常用数据结构或技巧
XiaoFengsen的博客
03-09 4854
链表 链表（单链表）的基本操作及C语言实现 链表中存放的不是基本数据类型，需要用结构体实现自定义： typedef struct Link { char elem;//代表数据域 struct Link * next;//代表指针域，指向直接后继元素 }link; next的值实际上就是下一个节点的地址，当前节点为末节点时，next的值设为空指针。像上面这种只包含一个指针域、由n个节点链接形成的链表，就称为线型链表或者单向链表，链表只能顺序访问，不能随机访问，链表这种存储方式最大缺点就是容易出现断链。
C/C++数据结构课程设计安排
程序设计
10-31 4978
数据结构课程设计安排课程设计学时：32学时课程设计目的：综合应用数据结构课程中所学的数据结构：线性表、栈、队列、数组、广义表、树、二叉树、图、查找表中的一种或多种数据结构完成一个较大问题的求解（其实这里的问题也并不太大，所用的数据结构可能是其中的多个，也可能是其中的一个两个）。从而培养学生综合应用基本数据结构分析、解决实际问题的能力，并进一步加深对所学知识的理解和掌握。课程设计要求：1、课程设计以组为单位开展，每组2~4名同学，自由组合，确定组长一名。
C++Primer Plus学习笔记
weixin_45068267的博客
04-08 1788
此博文是通过翻阅C++ Primer Plus中文第6版（2020），逐章学习记录笔记由此学习C++的基础特性和语法知识，有别于其它视频教学+代码+笔记的学习途径，更趋向传统的书籍+代码+笔记学习，Cpp第6版以C++11标准为主，学习C++基础编程绰绰有余.
c/c++bing（练习题）
二月鸟
04-02 969
1.下面程序的结果是:（ ） #include <stdio.h> #include <string.h> int main() { printf("%d\n", strlen("c:\test\121")) return 0; } strlen：获取字符串的有效长度，不包括’\0’ “c:\test\121”: 在该字符串中，\t是转移字符，水平制表，跳到下一个tab的位置；而\121表示一个字符，是讲121看做8进制数组，转换为10进制后的81，作业为ASCII
数据结构（C/C++）
weixin_44003941的博客
09-16 1265
一、数据结构 1、线性表 1.1 线性结构是什么： 是一个有序数据元素的集合，常见的线性结构有：线性表、栈、队列、双队列、数组、串 数据元素之间存在一对一的线性关系 1.2 线性结构的特点： 线性结构有唯一的首元素（第一个元素） 线性结构有唯一的尾元素（最后一个元素） 除首元素外，所有的元素都有唯一的“前驱” 除尾元素外，所有的元素都有唯一的“后继” 数据元素存在一对一的关系，除首元素和尾元素外，其他数据元素都是首尾相连的 1.3 线性表的顺序表示： 1.3.1 顺序表的定义（即顺序存储） 顺序
c++笔记2
weixin_70468627的博客
07-25 1399
c++笔记
【C++11】C++ STL（面试复习整理-2.0）
bandaoyu的note
07-06 1495
1、六大组件介绍 STL六大组件 容器：数据结构，用来存放数据 算法：常用算法 迭代器：容器和算法之间的胶合剂，“范型指针” 仿函数：一种重载了operator()的类，使得这个类的使用看上去像一个函数 配置器：为容器分配并管理内存 适配器：修改其他组件接口 2、容器 vector 底层为数组，支持随机访问，节点大小是动态的，支持下标访问。随机存取效率很高（O(1)），插入效率不高。 扩容原理：以原大小的两倍配置一份新空间，将原空间数据拷贝过来，会导致迭代器失效 常用函数 size()：.
深入解析C++的循环链表与双向链表设计的API实现
09-02
在C++编程中，循环链表和双向链表是两种重要的数据结构，它们在处理动态数据集合时提供了灵活且高效的方式。循环链表是单链表的一种变体，它的最后一个节点指向链表的第一个节点，形成了一个逻辑上的环。双向链表则...
用C++实现单向循环链表的解决方法
09-05
单向循环链表是一种线性数据结构，其中的每个元素（称为节点）包含一个数据域和一个指向下一个节点的指针。在循环链表中，最后一个节点的指针指向链表的第一个节点，形成一个环状结构。在C++中实现单向循环链表涉及...
c++语言实现双向循环链表
08-03
c++语言实现双向循环链表
C++ 中循环链表和约瑟夫环
08-30
C++ 中循环链表和约瑟夫环 C++ 中循环链表和约瑟夫环是一种重要的数据结构和算法思想。循环链表是一种特殊的链表结构，它的最后一个节点指向头结点，形成一个环。约瑟夫问题是站在圈内编号从1开始的n个人，报数到m...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1234
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
用cmake创建一个c++工程，调用c语言函数打印“c hello!”。
最新发布
LW_12345的博客
07-26 229
添加语言类型：在project命令中指定项目支持C和C++语言。设置标准：在CMakeLists.txt中明确设置C和C++的标准。添加库：使用创建C语言库，并用将其链接到C++可执行文件。这样，CMake就能正确识别C语言源文件，并将其链接到C++项目中。
C++ primer plus 第16章string 类和标准模板库, 关联容器
zhyjhacker的博客
07-25 684
C++ primer plus 第16章string 类和标准模板库, 关联容器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值