c++之编程练习（1）

米兰的小红黑

已于 2022-12-18 16:45:56 修改

阅读量184

点赞数

分类专栏： c++编程练习文章标签： c++ 算法 java

于 2022-12-09 16:21:53 首次发布

本文链接：https://blog.csdn.net/DUANJIAWEIDUANJIAWEI/article/details/128254170

版权

c++编程练习专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1、用两个栈实现队列

在这里插入图片描述
思路：
构建两个栈，一个栈只用来存放数据，每次有数据都放进去，当需要取数据的时候，可以将数据全部放到另一个栈里，根据站的先进后出的原则，另一个栈里的数据在被弹出就会实现队列先进先出的原则。

#include <stack>
class CQueue {
public:
    stack<int> *s1 = new stack<int>();
    stack<int> s2;
    CQueue() {
        
    }
    
    void appendTail(int value) {
        //s1.push(value);
        s1->push(value);
    }
    
    int deleteHead() {
        if(!s2.empty()){

        }else{
            while(!s1->empty()){
                s2.push(s1->top());
                s1->pop();
            }
        }
        if(s2.empty()){
            return -1;
        }
        int v = s2.top();
        s2.pop();
        return v;
    }
};

/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue* obj = new CQueue();
 * obj->appendTail(value);
 * int param_2 = obj->deleteHead();
 */

笔记：

#include <iostream>
#include <stack>

using namespace std;

int main(int argc, char *argv[])
{
    //栈的构建方式，其中new stack<int>()中的int不能省略。
    stack<int> *s = new stack<int>();
    s->push(100);//像栈顶存放元素
    s->push(100);
    s->push(100);
    s->pop();//删除栈顶元素，无返回值
    cout << s->top() << endl;//返回栈顶元素，有返回值
    cout << s->empty() << endl;//判断栈是否为空，返回值为bool类型
    cout << s->size() << endl;//返回栈的大小
    return 0;
}

2、包含min函数的栈

在这里插入图片描述
解题思路：
为保证取最小值，我们可以构建一个辅助栈，当判定入栈是最小值时，即可将该值存入辅助栈，则表明该值是现在栈里存入所有值的最小值。同理，当又出现最小值时，说明该值是现在栈里存入所有值的最小值。当有值被弹出时，也要判断该值是否与辅助栈的值相同，如果相同也应该一并弹出。

#include <stack>

class MinStack {
public:
    /** initialize your data structure here. */
    stack<int> *s1 = new stack<int>();
    stack<int> *s2 = new stack<int>();
    MinStack() {

    }
    
    void push(int x) {
        s1->push(x);
        if(s2 -> empty() || x <= s2->top()){
            s2 -> push(x);
        }
    }
    
    void pop() {
        if(s1->top() == s2->top()){
            s2->pop();
        }
        s1->pop();
    }
    
    int top() {
        return s1->top();
    }
    
    int min() {
        return s2->top();
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(x);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->min();
 */

3、从头到尾打印列表

在这里插入图片描述
解题思路：首先遍历列表将值放入栈中，然后根据栈先进后出的原则将值以此取出，就可以实现从尾到头打印的效果。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 #include <stack>
 #include <vector>
class Solution {
public:
    vector<int> v;
    stack<int> s;
    vector<int> reversePrint(ListNode* head) {
        while(head != NULL){
            s.push(head->val);
            head = head->next;
        }
        while(!s.empty()){
            v.push_back(s.top());
            s.pop();
        }
        return v;
    }
};

学习笔记：

/*
vector的迭代器是随机访问迭代器，因此迭代器+n可以通过编译，就是随机访问迭代器
capacity():空间能容纳元素最大个数。
size():空间中实际存放的元素个数。
push_back():末尾添加元素
at(int idx); //返回索引idx所指的数据，如果idx越界，抛出out_of_range异常。
operator[];//返回索引idx所指的数据，越界时，运行直接报错
front();//返回容器中第一个数据元素
back();//返回容器中最后一个数据元素
insert(const_iterator pos, int count,ele);//迭代器指向位置pos插入count个元
素ele.
push_back(ele); //尾部插入元素ele
pop_back();//删除最后一个元素
erase(const_iterator start, const_iterator end);//删除迭代器从start到end之
间的元素
erase(const_iterator pos);//删除迭代器指向的元素
clear();//删除容器中所有元素

*/
void test03(){
    vector<int> *v = new vector<int>();
    v->push_back(10);
    v->push_back(20);
    v->push_back(30);
    v->push_back(40);
    v->push_back(50);
    v->push_back(60);
    //使用迭代器遍历vector单端动态数组
    for(vector<int>::iterator s = v->begin(); s!=v->end(); s++){
        cout << *s << endl;
    }
    //cout << v[1] << endl  错误 v为地址不是对象 ;
    cout << (*v)[1] << endl;
    cout << v->front()<< endl;
    cout << v->back() << endl;
    //迭代器指向位置pos插入count个元素ele.
    v->insert(v->begin()+2,3,11);
    //erase(const_iterator start, const_iterator end);
    //删除迭代器从start到end之间的元素
    v->erase(v->begin(),v->end()-1);
    vector<int> *v1 = new vector<int>();
}

4、反转链表

在这里插入图片描述
解题思路：
假设链表为 1→2→3→∅，我们想要把它改成 ∅←1←2←3。
在遍历链表时，将当前节点的 \textit{next}next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode *pre = NULL;
        ListNode *head2 = NULL;
        while(head != NULL){
            head2 = head->next;
            head->next = pre;
            pre = head;
            head = head2;
        }
        return list;
    }
};

学习笔记：

5、复杂链表的复制

在这里插入图片描述

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/

class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head == NULL){
            return NULL;
        }
        Node *tmpe = head;
        while(tmpe != NULL){
            Node *copy_Node = new Node(tmpe->val);
            copy_Node->next = tmpe->next;
            tmpe->next = copy_Node;
            tmpe = tmpe->next->next;
        }
        Node *tmpe1 = head;
        while(tmpe1 != NULL){
            Node *tmpe2 = tmpe1->next;
            tmpe2->random = (tmpe1->random != NULL) ? tmpe1->random->next : NULL;
            tmpe1 = tmpe1->next->next;
        }
        
        Node *node = head;
        Node* headNew = head->next;
        while(node != NULL){
            Node *node1 = node->next;
            node->next = node->next->next;
            if(node1->next != NULL){
                node1->next = node1->next->next;
                node = node->next;
            }else{
               break;
            }
        }
        return headNew;

    }
};

6、替换空格

在这里插入图片描述

class Solution {
public:
    string replaceSpace(string s) {
        int ret = 0;
        while((ret = s.find(' ')) < s.size()){
            s.replace(ret,1,"%20");
        }
        return s;
    }
};

学习笔记：

#include <iostream>

using namespace std;
/*
 *
1 string 构造函数
    string();//创建一个空的字符串 例如: string str;
    string(const string& str);//使用一个string对象初始化另一个string对象
    string(const char* s);//使用字符串s初始化
    string(int n, char c);//使用n个字符c初始化
*/
int main(int argc, char *argv[])
{

    string str = "hahahah";
    //char& operator[](int n);//通过[]方式取字符
    //char& at(int n);//通过at方法获取字符
    cout << str[1] << endl;
    cout << str.at(1) << endl;
    //字符串拼接
    //string& operator+=(const string& str);//重载+=操作符
    string str1 = "xixixixi";
    str += str1;
    cout << str << endl;
    //string& operator+=(const char* str);//重载+=操作符
    str += "xixixixi";
    cout << str << endl;
    //string& append(const char *s);//把字符串s连接到当前字符串结尾
    str.append("dada");
    cout << str << endl;
    //字符串查找替换
    //int find(const string& str, int pos = 0) const; //查找str第一次出现位置,从pos开始查找
    string str3 = "ddd";
    int val = str.find(str);
    cout << val << endl;//find函数在找不到时，会返回-1.
    //int find(const char* s, int pos, int n) const; //从pos位置查找s的前n个字符第一次位置
    int val1 = str.find("ddd");
    cout << val1 << endl;//find函数在找不到时，会返回-1.
    //int find(const char c, int pos = 0) const; //查找字符c第一次出现位置
    int val2 = str.find('d');
    //int rfind(const string& str, int pos = npos) const;//查找str最后一次位置,从pos开始查找
    //int rfind(const char* s, int pos = npos) const;//查找s最后一次出现位置,从pos开始查找
    //int rfind(const char* s, int pos, int n) const;//从pos查找s的前n个字符最后一次位置
    //int rfind(const char c, int pos = 0) const; //查找字符c最后一次出现位置
    //string& replace(int pos, int n, const string& str); //替换从pos开始n个字符为字符串str
    //string& replace(int pos, int n, const char* s); //替换从pos开始的n个字符为字符串s
    str.replace(0,2,"sss");
    cout << str << endl;
    str.replace(0,2,str1);
    cout << str << endl;

    return 0;
}