ACWing语法基础课STL相关代码习题

​

数字排列

输入一组数字（可能包含重复数字），输出其所有的排列方式。

数据范围
输入数组长度 [0,6][0,6]。

样例
输入：[1,2,3]

输出：
      [
        [1,2,3],
        [1,3,2],
        [2,1,3],
        [2,3,1],
        [3,1,2],
        [3,2,1]
      ]

class Solution {
public:
    vector<vector<int>> permutation(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<vector<int>> a;
        do
        {
            a.push_back(nums);
        }while(next_permutation(nums.begin(),nums.end()));
        return a;
    }
};

此题要求输入一组数字，进行全排列，则需要使用到arlgorithm中的next_permutation函数，进行全排列，同时在进行全排列循环前，要先对输入的数字从小到大进行排序，排序可以使用sort函数进行排序，排序的目的是防止在接下来的全排序中，输出的结果不全。

在进行全排列循环时，应该使用do while，进行循环，如果直接使用while，则，在输出时，输出结果减少一组，即第一组，使用do while则可以避免。

---

二进制中1的个数

输入一个32位整数，输出该数二进制表示中1的个数。

注意：
负数在计算机中用其绝对值的补码来表示。
数据范围
−100≤输入整数 ≤100

样例1
输入：9
输出：2
解释：9的二进制表示是1001，一共有2个1。

样例2
输入：-2
输出：31
解释：-2在计算机里会被表示成11111111111111111111111111111110，
      一共有31个1。

class Solution {
public:
    int NumberOf1(int n) {
        unsigned int ans=0;
        unsigned int a=n;
        while(a!=0)
        {
            if(a&1)
            {
                ans++;
            }
            a>>=1;
        }
        
        return ans;
    }
};

首先，传入了一个数字，然后定义一个无符号整型变量，令其为n，由于数据在计算机中的存储形式都是2进制，所以不需要人为的将数据转换为2进制，用与&运算即可判断共有多少个1，每次判断完之后，记得将变量右移，进行下一位比较。

---

三元组排序

给定 N个三元组 (x,y,z)，其中 x是整数，y是浮点数，z是字符串。
请你按照 x从小到大的顺序将这些三元组打印出来。
数据保证不同三元组的 x值互不相同。
输入格式
第一行包含整数 N。
接下来 N行，每行包含一个整数 x，一个浮点数 y，一个字符串 z，表示一个三元组，三者之间用空格隔开。

输出格式
共 N行，按照 x从小到大的顺序，每行输出一个三元组。
注意，所有输入和输出的浮点数 y
均保留两位小数。
数据范围

1≤N≤10000,
1≤x,y≤10⁵
,
字符串总长度不超过 10⁵
。

输入样例：
5
32 1.36 nsyiupnnhc
18 4.53 fmofzwrah
33 4.86 wzuymbm
1 3.93 gtnrwcebt
31 4.53 gcllxioc

输出样例：
1 3.93 gtnrwcebt
18 4.53 fmofzwrah
31 4.53 gcllxioc
32 1.36 nsyiupnnhc
33 4.86 wzuymbm

#include <bits/stdc++.h>
#include <cstring>
const int N = 10010;
using namespace std;
struct Node
{
    int x;
    double y;
    string z;
    bool operator < (Node & W)
    {
        return x < W.x;
    }
};
int main()
{
    int n;
    cin>>n;
    Node a[N];
    for (int i=0;i<n;i++)
    {
        cin>>a[i].x>>a[i].y>>a[i].z;
    }
    sort(a,a+n);
    for(int i=0;i<n;i++)
    {
        cout<<a[i].x<<" "<<fixed<<setprecision(2)<<a[i].y<<" "<<a[i].z<<endl;
    }
}

在结构体中重载<在主函数中sort排序需要用到。在输出时，需要用到 fixed<<setprecision(2)来确保输出浮点数时为2位小数。

---

和为s的两个数字

输入一个数组和一个数字 s，在数组中查找两个数，使得它们的和正好是 s。
如果有多对数字的和等于 s，输出任意一对即可。
你可以认为每组输入中都至少含有一组满足条件的输出。
数据范围
数组长度 [1,1002]。

样例
输入：[1,2,3,4] , sum=7

输出：[3,4]

class Solution {
public:
    vector<int> findNumbersWithSum(vector<int>& nums, int target) {
        int i,j;
        
        for(i=0;i<nums.size();i++)
        {
            for(j=i+1;j<nums.size();j++)
            {
                if(nums[i]+nums[j]==target)
                {
                    return { nums[i],nums[j] };
                }
            }
        }
        return {};
    }
};

由于只输出一组满足的数据，所以只需要双重循环直到找到合适的数据输出即可。

---

最小的k个数

输入 n个整数，找出其中最小的 k个数。

注意：

输出数组内元素请按从小到大顺序排序;
数据范围
1≤k≤n≤1000

样例
输入：[1,2,3,4,5,6,7,8] , k=4

输出：[1,2,3,4]

方法一(小根堆法）

class Solution {
public:
    vector<int> getLeastNumbers_Solution(vector<int>& input, int k) {
        vector<int> result;

        priority_queue<int, vector<int>, greater<int>> min;

        for (int i = 0; i < input.size(); i++) 
        {
            min.push(input[i]);
        }

        for (int i = 0; i < k; i++) 
        {
            result.push_back(min.top());
            min.pop();
        }

        return result;
    }
};

采用小根堆，将所有的数据放入小根堆中，不断取前堆顶元素，直至取够k个。

方法二（大根堆法）

class Solution {
public:
    vector<int> getLeastNumbers_Solution(vector<int> input, int k) {  
        vector<int> result;

        priority_queue<int> max;

        for (int i = 0; i < k; i++)     //将input中的元素放入大根堆当中
        {
            max.push(input[i]);
        }

        for (int i = k; i < input.size(); i++)      //从第k个元素开始和堆顶比较
        {
            if (input[i] < max.top()) 
            {
                max.pop();
                max.push(input[i]);
            }
        }

        while (max.size())     //将大根堆当中的元素取出放入结果数组
        {
            result.push_back(max.top());
            max.pop();
        }

        reverse(result.begin(),result.end());//由于数组中的元素是从大到小排序，使用reverse使得数组翻转。

        return result;

    }
};

大根堆法如代码中注释所写。

---

用两个栈实现队列

请用栈实现一个队列，支持如下四种操作：

push(x) – 将元素x插到队尾；
pop() – 将队首的元素弹出，并返回该元素；
peek() – 返回队首元素；
empty() – 返回队列是否为空；
注意：

你只能使用栈的标准操作：push to top，peek/pop from top, size 和 is empty；
如果你选择的编程语言没有栈的标准库，你可以使用list或者deque等模拟栈的操作；
输入数据保证合法，例如，在队列为空时，不会进行pop或者peek等操作；
数据范围
每组数据操作命令数量 [0,100]
。

样例
MyQueue queue = new MyQueue();

queue.push(1);
queue.push(2);
queue.peek();  // returns 1
queue.pop();   // returns 1
queue.empty(); // returns false

class MyQueue {
public:
    /** Initialize your data structure here. */
    stack<int> a;
    stack<int> b;
    MyQueue() {
        
    }
    
    /** Push element x to the back of queue. */
    void push(int x) {
        a.push(x);
    }
    
    /** Moves the element from one stack to another stack. */
    void move(stack<int> &a,stack<int> &b)
    {
        while(a.size())
        {
            b.push(a.top());
            a.pop();
        }
    }
    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        move(a,b);
        int element;
        element=b.top();
        b.pop();
        move(b,a);
        return element;
    }
    
    /** Get the front element. */
    int peek() {
        move(a,b);
        int element;
        element=b.top();
        move(b,a);
        return element;
    }
    
    /** Returns whether the queue is empty. */
    bool empty() {
        return a.empty();
    }
};

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * bool param_4 = obj.empty();
 */

要弹出数据时，先将a中的元素压入b，再弹出b栈顶元素，再将b中元素弹回a。
将栈a中的元素移动到栈b时，用for循环可能会导致segmentation fault，直接使用while可以避免

---

从尾到头打印链表

输入一个链表的头结点，按照 从尾到头 的顺序返回节点的值。

返回的结果用数组存储。

数据范围
0≤链表长度 ≤1000。

样例
输入：[2, 3, 5]
返回：[5, 3, 2]

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> printListReversingly(ListNode* head) {            
        vector<int> a;
        vector<int> b;
        while(head)
        {
            a.push_back(head->val);
            head=head->next;
        }
        for (int i=a.size()-1;i>=0;i--)
        {
            b.push_back(a[i]);
        }
        return b;
    }
};

先将链表中元素从头到尾输入到一个数组中，然后再将该数组中元素倒序输入到另一个数组中。或者使用reverse函数也可以实现。

---

调整数组顺序使得奇数位于偶数前面

输入一个整数数组，实现一个函数来调整该数组中数字的顺序。

使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分。

数据范围
数组长度 [0,100]。
数组内元素取值范围 [0,100]。

样例
输入：[1,2,3,4,5]

输出: [1,3,5,2,4]

class Solution {
public:
    void reOrderArray(vector<int> &array) {
    vector<int> a;
    for(int i=0;i<array.size();i++)
    {
        if(array[i]%2==1)
        {
            a.push_back(array[i]);
        }
    }
     for(int i=0;i<array.size();i++)
    {
        if(array[i]%2==0)
        {
            a.push_back(array[i]);
        }
    }
    array=a;
    }
};

循环两次，第一次先将数组中的奇数输入到新的数组中，第二次循环输入偶数。

---

0到n-1中缺失的数字

一个长度为 n−1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0到 n−1之内。

在范围 0到 n−1的 n个数字中有且只有一个数字不在该数组中，请找出这个数字。

数据范围
1≤n≤1000

样例
输入：[0,1,2,4]

输出：3

class Solution {
public:
    int getMissingNumber(vector<int>& nums) {
        if(nums.empty())
            return 0;
        int ans;
        int i;
        int sum=0;
        for (i=0;i<nums.size();i++)
        {
            sum+=nums[i];
        }
        int n=nums.size();
        int total=n*(n+1)/2;
        ans=total-sum;
        return ans;
    }
};

用1到n求和减去数组中元素的和即可求出缺失的数字。

方法二（二分法）

---

数字在排序数组中出现的次数

统计一个数字在排序数组中出现的次数。
例如输入排序数组 [1,2,3,3,3,3,4,5]和数字 3，由于 3在这个数组中出现了 4次，因此输出 4。
数据范围
数组长度 [0,1000]。

样例
输入：[1, 2, 3, 3, 3, 3, 4, 5] ,  3

输出：4

class Solution {
public:
    int getNumberOfK(vector<int>& nums , int k) {
        
        int count=0;
        int i;
        for (i=0;i<nums.size();i++)
        {
            if (nums[i]==k)
            {
                count++;
            }
        }
        return count;
        }
};

循环判断即可。