c++软件开发算法

于 2021-08-20 15:51:40 发布
阅读量342 收藏 1
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangwangchang/article/details/119825476
版权

数组：

​

//在连续空间存储相同类型的元素。
1、定义数组：int arr1[5] = {1 , 2, 4 ,5};   int a[100] = {0};
2、数组的大小： n = sizeof a/sizeof(int)

1、最大连续的1的个数

//输入：[1,1,0,1,1,1]  输出：3
class Solution {
public:
    int findMaxConsecutiveOnes(vector<int>& nums) {
        int count =0;
        int maxcount = 0;
        for(int i = 0 ;i < nums.size();i++) {
            if(nums[i] == 1) {
                count++;
            }
            else {
                maxcount = max(maxcount,count);
                count = 0;
            }
        }
        maxcount = max(maxcount,count);  //最大连续的1的个数可能出现在最后
        return maxcount;
    }
};

2、移动零

//输入: [0,1,0,3,12]   输出: [1,3,12,0,0]
//第一种直接覆盖
class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int n = nums.size();
        int index = 0;
        for(int i=0;i < n;i++) {
            if(nums[i] != 0) {
                nums[index++] = nums[i];
            }
        }
        while(index < n) {
            nums[index++] =0;
        }
    }
};

3、移除元素

//移除一个数组中所有等于val的元素，并返回数组新的长度
//输入：nums = [3,2,2,3], val = 3 输出：2, nums = [2,2]
//思想和上一个一样，主要就是可以看成2个数组，一个指向一个，然后寻找符合的元素按照index顺序排好，其余元素添0.
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int  n = nums.size();
        int index = 0;
        for(int i = 0 ; i < n; i++)  {
            if(nums[i] != val) {
                nums[index++] =nums[i];
            }
        }
        return index;
    } 
};

链表：

1、创建链表  2、添加元素 3、访问元素 
4、查找元素  5、删除元素 6、链表长度
    //链表定义

ListNode* head = new ListNode(5);
//ListNode* head = new ListNode();
//head->val = 5;  数值为5 的节点

//用来定义单链表结构
struct node
{
	int data; //数据域
	node* next; //指针域
};
class list
{
	node* head;
public:
	list()
	{
		head = new node;//创建堆区  指针head指向node堆区的首地址，然后让其指向空
		head->next = NULL;  //NUll为一个空地址
	}
};

1、删除链表元素

//输入：head = [1,2,6,3,4,5,6], val = 6  输出：[1,2,3,4,5]
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 * };

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
       
        //删除头节点 
        while (head !=NULL && head->val == val) {
            ListNode * tmp = head;
            head  = head->next;
            delete tmp;                
        }
        //删除非头结点
        ListNode *p = head;
        while(p  != NULL  && p->next != NULL ) {
            if(p->next->val == val)  {
                ListNode *tmp= p->next;
                p->next = p->next->next;
                delete tmp;
            }
            else {
                p =p->next;
            }
        }
        return head;    
    }
};

2、反转链表

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* temp; // 保存cur的下一个节点
        ListNode* cur = head;
        ListNode* pre = NULL;
        while(cur) {
            temp = cur->next;  // 保存一下 cur的下一个节点，因为接下来要改变cur->next
            cur->next = pre; // 翻转操作
            // 更新pre 和 cur指针
            pre = cur;
            cur = temp;
        }
        return pre;
    }
};

3、判断链表是否有环

class Solution {
public:
    bool hasCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fast->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
            // 快慢指针相遇，说明有环
            if (slow == fast) return true;
        }
        return false;
    }
};
//slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while(fast != NULL && fast->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
            // 快慢指针相遇，此时从head 和 相遇点，同时查找直至相遇
            if (slow == fast) {
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while (index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2; // 返回环的入口
            }
        }
        return NULL;
    }
};

4、链表倒数第k个元素

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyNode = new ListNode(0, head);
        ListNode* slow = dummyNode;
        ListNode* fast = dummyNode;
        //令slow和fast距离相差n
        while (n--) {
            fast = fast->next;
        }
        //令fast最终停留在尾结点，因为slow和fast相差n，则slow位置为尾结点的前n个位置，即slow为整个链表倒数第n+1个结点，也就是第n个结点的前驱结点
        while (fast->next) {
            fast = fast->next;
            slow = slow->next;
        }
        //令倒数第n个结点的前驱结点指向其下一结点的next
        slow->next = slow->next->next;
        return dummyNode->next;
    }
};

队列：

//先进先出  相当于一个管道  一端进一端出
queue容器 相当于队列，先进先出   
q.push() //队尾进入数据   q.back() //返回最后一个元素
q.pop() //队头出数据      q.front() //返回第一个元素
//单端队列  一个口只能进，一个口可以出
//插入 只能插到最后   删除只能删除头 
//创建队列  添加元素  获取元素  删除元素 判断队列是否为空  队列长度  遍历队列（边遍历边删除）

1、最近的请求次数

//["RecentCounter", "ping", "ping", "ping", "ping"][[], [1], [100], [3001], [3002]]
//输出：[null, 1, 2, 3, 3]
class RecentCounter {
public:
    RecentCounter() {}
//使用队列，一直检查队列头部和插入时间是否大于3000，大于就弹出
    int ping(int t) {
       q.push(t); 
       while( t - q.front() > 3000) {
           q.pop();  
       }
       return q.size();
    }
private:
     queue<int> q;
};

2、滑动窗口最大值

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        deque<int> q;
        //在队列后面添加数据，把前面数据小的全部删除。
        vector<int> ans; 
        for(int i = 0 ;i < nums.size(); i++) {
            //当前遍历的元素的值比队尾大，让队尾元素出去  
            while(! q.empty()  && q.back() <  nums[i] ) {
                 q.pop_back();
            }
            //当遍历的元素入栈，那么队列的元素头部最大
            q.push_back(nums[i]);
            //如果窗口满状态，就可以得到窗口最大值啦
            if(i >= k - 1) {
                ans.push_back(q.front());
                if(nums[i - k + 1] == q.front()) {
                    q.pop_front();
                }
            }
        }
        return ans;
    }
};

栈（stack）:

先进后出   ： A B C  ->  C B A   
1、怎么创建栈

1、有效括号

class Solution {
public:
    bool isValid(string s) {
        int n = s.size();
        if(n % 2 == 1) return false;
       unordered_map<char, char> pair = { {')', '('},{']', '['},{'}', '{'}};
        stack<char> stk;
        for(char ch : s) { //在s中遍历 字符串s中全部字符的存在 
        //左括号压进栈，后面进入的先匹配
            if(pair.count(ch)) {  //字符ch对应键值个数的多少
               if(stk.empty() || stk.top() != pair[ch]) return false; 
               stk.pop();
            }
            else  stk.push(ch);
        }
        return stk.empty();
    }
};

class Solution {
public:
    bool isValid(string s) {
        stack<char> st; 
        for(int i = 0; i < s.size(); i++) {   // if else  互斥 只能执行一个
            if (s[i] == '(') st.push(')'); //先进匹配，如果 有左括号，就压进去右括号，
            else if (s[i] == '{') st.push('}');
            else if (s[i] == '[') st.push(']');
            else if (st.empty() || st.top() != s[i]) return false;
            else st.pop(); // st.top() 与 s[i]相等，栈弹出元素
        }
        return st.empty();
    }    
};

2、下一个更大元素

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        stack<int> s; //记录数组的值
        //主要就先求出，主数组的下一个更大元素，然后直接匹配
        //转换成查找后面元素是否大的问题
        unordered_map <int,int> map; //存放下一个最大值
        for(int i = nums2.size() - 1 ;i >=0; i--) {
           while(! s.empty() && s.top() <= nums2[i]) {
               s.pop();
           }
           map[nums2[i]] = s.empty() ? -1: s.top();
           s.push(nums2[i]);
        }  
        for(int i = 0; i < nums1.size();i++) {
            nums1[i] = map[nums1[i]];
        }
        return  nums1;
    }
};

哈希表：

哈希表：key : value   可以通过key得到value  
通过key值  哈希函数对应，找到内存地址  
1、哈希碰撞：两个不同的key值对应同一个哈希函数，得到相同的内存地址。（链表）

1、存在重复元素

// 输入: [1,2,3,1] 输出: true
class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        for(int  i = 0;i < nums.size()-1; i++) {
               if(nums[i] == nums[i+1]) {  
                   return true;
               }  
        }
        return false;
    }
};
 
class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_set<int> s;
        for(int x: nums) {
            if(s.find(x) != s.end())  //find这个函数，找不到会返回end();  != :找到这个元素了
               return true;
            s.insert(x);
        }
        return false;
    }
};

2、找不同

//输入：s = "abcd", t = "abcde"  输出："e"
class Solution {
public:
    char findTheDifference(string s, string t) {
       vector<int> v(26,0);
       for(char x : s) {
           v[x-'a']++; 
       }
       for(char x : t) {
           v[x- 'a']--;
           if(v[x - 'a'] < 0) {
               return x;
           }
       }
        return ' '; 
    }
};

集合set：

1、检查某个元素是否存在
2、重复元素

1、设计哈希集合

class MyHashSet {
public:
    /** Initialize your data structure here. */
    MyHashSet() {
        map.resize(1000010,0);
    }  
    void add(int key) {
        map[key] = true;
    }
    void remove(int key) {
         map[key] = false;
    } 
    /** Returns true if this set contains the specified element */
    bool contains(int key) {
        return  map[key];
    }
private:
     vector<bool> map;
};

树：

//二叉树定义：
struct TreeNode {
    int val;
    TreeNode *right;
    TreeNode *left;
    TreeNode(int x) :val(x), left(NULL) ,right(NULL) {}   //构造函数
};

1、递归法 前中后遍历

//前中后遍历：
clss Solution {
public:
        void traversal(TreeNode *cur,vector<int> &vec) {  //前序遍历
            if(cur == NULL) return ;
            vec.push_back(cur->val);
            traversal(cur->left,vec);
            traversal(cur->right,vec);
        }
        void travesal(TreeNode *cur,vector<int> &vec) {   //中序遍历
            if(cur == NULL) return;
            travesal(cur->left,vec);
            vec.push_back(cur->val);
            travesal(cur->right,vec);
        }
        void travesal(TreeNode *cur,vector<int> &vec) {   //后序遍历
            if(cur == NULL) return;
            travesal(cur->left,vec);
            travesal(cur->right,vec);
            vec.push_back(cur->val);
        }
    
        vector<int> preorderTraverasl(TreeNode * root) {
            vector<int> result;
            travelsal(root,result);
            return result;
        }

};

2、用栈实现二叉树遍历

//用栈实现二叉树遍历 
//栈先进后出 队列先进先出
//前序遍历是中左右，每次先处理的是中间节点，那么先将跟节点放入栈中，然后将右孩子加入栈，再加入左孩子。
class solution {
public:
        vector<int> preorderTraversal(TreeNode *root) {
            stack<TreeNode*> st;  //定义一个栈，每个节点的类型为 树节点指针
            vector<int> result;
            if(root == NULL ) return result;
            st.push(root);   // 先将根节点入栈
            //一直执行，直到栈为空，然后将左节点出栈，然后右节点。
            while(!st.empty()) {
                TreeNode* node = st.top(); //定义一个栈顶指针
                st.pop();                  //弹出根节点
                result.push_back(node->val); //将结果存在vector容器中
                if（node->right）  st.push_back(node->right); //右  （空节点不如栈）
                if（node->left）   st.push_back(node->left);  //左   
            }
            return result;
        }
};

//中序遍历（迭代法）
//处理：将元素放到result数组中
//遍历节点      指针的遍历来帮助访问节点，栈则用来处理节点上的元素。
//中序遍历是左中右，先访问的是二叉树顶部的节点，然后一层一层向下访问，直到到达树左面的最底部，再开始处理节点  
class solution {
public:
    vector<int> inorderTraversal(TreeNode *root) {
        vector<int> result;
        stack<TreeNode*> st;    
        TreeNode* cur =root;   //curr定义为将要入栈的结点，初始化为root
        while(cur != NULL || !st.empty()) {
            if(cur != NULL) {  //指针访问节点，访问到最底层
                st.push(cur);  //将访问的节点放进栈
                cur = cur->left;
            }
            else {
                cur = st.top(); //从栈弹出数据，就是要放进数组的数据  
                st.pop();
                result.push_back(cur->val);  //中
                cur = cur ->right;           //右
            }
        }
        return result;
    }
};

//后序遍历
 if (node->left) st.push(node->left); // 相对于前序遍历，这更改一下入栈顺序 （空节点不入栈）
 if (node->right) st.push(node->right); // 空节点不入栈  
 reverse(result.begin(), result.end()); // 将结果反转之后就是左右中的顺序了
        return result;

堆（heap）：

删除节点：只能删除堆顶元素，  将最后一个元素喝堆顶元素就行交换，然后重新构造大小顶堆。

1、前K个高频元素

class Solution {
public:
     static bool compare(  pair<string, int>& s1,  pair<string, int>& s2) {
        // 频率相等，按字母排序
        if(s1.second == s2.second) return s1.first < s2.first;
        // 按照频率排序
        else return s1.second > s2.second;
    }
    vector<string> topKFrequent(vector<string>& words, int k) {
        //用哈希表进行查找
        //统计出现频率
        unordered_map<string,int> m; 
        for(string word : words) {
            m[word] ++;
        }
        //将map表放进vector容器中 进行排序
        vector<pair<string,int>> v(m.begin(),m.end());
        sort(v.begin(),v.end(), compare);
        vector<string> ans; //记录输入
        for(int i = 0; i < k; i++ ) {
            ans.push_back(v[i].first);
        }
        return ans;
    }
};
活在自己世界中
关注
【C++软件调试技术】C++软件开发维护过程中典型软件异常问题的排查与总结
dvlinker的技术专栏
04-15 8万+
本文以问答的方式进行展开，罗列了C++软件日常开发和维护中遇到的多个软件调试问题及有代表性的场景，给出详细的处置思路和处理办法，以供大家借鉴和参考。
C++ 应用软件开发从入门到精通详解
最新发布
dvlinker的技术专栏
06-21 3万+
本文详细介绍一下Windows平台下用C++开发应用软件的诸多内容，以供大家借鉴或参考。
软件开发算法大全
08-29
涵盖基本算法 描述详细 可用于对软件开发前期基础学习 专业理论很有帮助。
让你提前认识软件开发(14)：程序中的算法
weixin_34080571的博客
06-27 542
第1部分 又一次认识C语言程序中的算法 【文章摘要】        算法(Algorithm)，是程序的灵魂。著名计算机科学家、图灵奖获得者沃思曾提出过一个公式：数据结构+算法=程序。可见，算法在程序中占有非常重要的地位。        在实际的软件开发项目中，无论是有意设计或是无意为之。我们差点儿随时在和算法打交道。小到定义一个变量，大到编写一个函数，这些都是算法的实现过程。        ...
软件开发随想：算法
weixin_34216107的博客
05-12 152
福州小啊，公司在城市的一头，家在城市的另一头，但照样可以骑着电动车上班。不过每天都要在家楼下寄存电动车。寄的时候取张带着号码的月卡，取的时候就要上交月卡。这样日复一日。但突然有天急着寄车取卡回家，但看车的大爷找了几遍硬是没有找到我的卡，后来还是自己动手找了一遍才最终看到。 这是生活中的小事，但对于软件开发中的算法应用却有很多启示： 1）看车大爷如果每次在收卡时候...
C++后台开发--算法方面
m0_38099899的博客
07-08 502
1、逆转单链表； https://blog.csdn.net/m0_38099899/article/details/80957235 2、链表带环检测以及环入口； https://blog.csdn.net/m0_38099899/article/details/80957255 3、链表排序(nlogn不退化)；     https://blog.csdn.net/one_piece...
C++实现基础的算法
MSFollower的博客
08-14 777
针对找工作时，遇到的数据结构基础算法做一个简单的回顾和积累。 大数相乘： //大数相乘 int Bigdata_multiple(char string1[], char string2[],int length1,int length2) { int result[length1+length2+2]; for (int iindex = 0; iindex &lt; le...
C++面试题笔试题C++ 数据结构算法笔试题资料合集.zip
04-09
C++开发工程师面试题库.docx C++技能测试试卷一及答案.docx C++技能测试试卷二及答案.docx c++笔试面试宝典.docx C++笔试面试题带答案.docx c++笔试题汇总.pdf C++经典面试题库 附带参考答案.docx C++语言程序设计...
C++软件开发工程师JD
11-11
本资源摘要信息全面、详细地阐述了C++软件开发工程师的岗位职责、任职要求和知识点，涵盖了Windows平台下的开发、图像处理和视频处理算法、计算机体系知识结构等多方面的知识领域，为从事C++软件开发工程师职业的...
c++麻将胡牌算法，癞子胡牌算法
04-02
在IT行业中，游戏开发是一项非常有趣的领域，而麻将游戏的编程更是其中的一种挑战。本项目主要探讨了如何使用C++语言实现麻将胡牌...在实际应用中，这样的算法可以用于开发麻将游戏软件，为用户提供真实的麻将体验。
软件开发中的十五个经典算法研究
08-09
本经典算法研究系列，涵盖 A*.Dijkstra.DP.BFS/DFS.红黑树.KMP.遗传.启发式搜索.图像特征提取SIFT.傅立叶变换.Hash.快速排序.SPFA.快递选择 SELECT 等15 个经典基础算法，共计 31 篇文章，包括算法理论的研究与阐述，及其编程的具体实现。很多个算法都后续写了续集，如第二个算法：Dijkstra 算法，便写了 4 篇文章；sift 算法包括其编译及实现，写了5篇文章；而红黑树系列，则更是最后写了6篇文章，成为了国内最为经典的红黑树教程。
C/C++软件项目开发实例（标准文档+代码+ ）
08-30
C/C++软件项目开发实例，有做好的一个完整的项目。实力完整，模块化编程
C++算法-图算法
12-13
介绍关于图的算法，C++语言描述。介绍关于图的算法，C++语言描述。
A*算法C/C++代码
07-30
的VS2013实现A*算法，包含2个工程，一个采用C++自带优先队函数实现OPEN表的插入删除及排序，一个用单链表实现。
C++算法大全（初级和中级程序员必备）
05-30
任何程序语言都只是一个交流的工具，精通C++, pascal等语言都算不了什么。语言的灵魂是算法，精通算法，才是牛人。此书适合于已经掌握了C++语法的人员浏览。初级和中级程序员必须掌握的算法。
面试软件开发必会的排序算法
Talk is cheap,show me your code
07-21 992
总结分析了常用的6大排序算法的算法思想、算法复杂度，并给出了参考代码，代码均已通过验证。
软件开发工程师知识整理（算法）
MELF晓宇的博客
08-25 1449
1.2 算法 算法：算法是为了解决某类问题而规定的一个有限长的操作序列。 1.2.1 一个算法必须满足以下五个重要特性 有穷性。一个算法必须总是在执行有穷步后结束，且每一步都必须在有穷时间内完成。 确定性。对千每种情况下所应执行的操作，在算法中都有确切的规定，不会产生二义性，使算法的执行者或阅读者都能明确其含义及如何执行。 可行性。算法中的所有操作都可以通过已经实现的基本操作运算执行有限次来实现。 输入。一个算法有零个或多个输入。当用函数描述算法时，输入往往是通过形参表示的，在它们被调用时，从主调函数获得
c++开发软件_无代码编程的兴起：借助平台，无需编写任何基础代码即可开发软件...
weixin_39569051的博客
11-22 340
代码是软件和应用程序的核心。每行代码都是一条逐步指令的机制，与计算机、服务器和其他计算机共同执行操作逻辑。要创建这些指示，必须知道如何编写代码，而这项技能极为短缺。如果无需编写任何代码就可以开发软件呢？这是无代码开发的前提。通过借助无代码平台，无需编写任何基础代码即可开发软件。网站构建平台 Webflow 的联合创始人兼首席执行官弗拉德·马格达林(Vlad Magdalin)说：“无代码编程允许不...
软件开发实训需要用到的算法和结构_算法和数据结构-上机实验大纲
weixin_39777018的博客
12-20 120
1/8《算法与数据结构》实验(上机)大纲课程名称：算法与数据结构上机学时：16学时适用专业：软件工程一、实验(上机)课程的性质、目的与任务：《算法与数据结构》是软件工程专业的一门专业必修课，是理论与实践并重的课程。实验是该课程实践教学环节的重要环节，它的内容覆盖了算法与数据结构的各个主要部分。通过实验可以加深对数据结构基本概念、基本理论的理解，使学生巩固和运用所学知识以解决实际的具体问题，同时...
C++贪心算法源码实现与开发解析
C++广泛应用于软件开发领域，特别是在系统软件、游戏开发、实时物理模拟等方面。基于C++实现的贪心算法源码.zip这个资源包包含了用C++语言编写的所有相关源文件，适用于想要深入学习和了解贪心算法在实际编程中如何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值