使用STL algorithm来轻松解决几道面试题

最新推荐文章于 2024-04-25 15:13:22 发布

aiYuqiong

最新推荐文章于 2024-04-25 15:13:22 发布

阅读量564

点赞数 1

本文链接：https://blog.csdn.net/weixin_40825228/article/details/81092187

版权

1、生成一个序列的全排列。

题一：生成N个不同元素的全排列。

测试代码：

//测试函数
int main()
{
    char elements[]={'a','b','c','d'};
    const int N=sizeof(elements)/sizeof(elements[0]);
    std::vector<char> intArray(elements,elements+N);

    int index=0;
    do
    {
        std::cout<<++index<<" \t";
        traverseEle(intArray);
    }while(std::next_permutation(intArray.begin(),intArray.end()));

    return 0;
}

执行结果：

2、生成从N个不同的元素中取出M个元素的不同排列组合。

例子：求从char elements[]={'a','b','c','d','e','f','g'}取出三个不同的元素组合的排列集合

思路：对{1,1,1,0,0,0,0}做全排列。对于每个排列输出对应位置为1的元素。

测试代码：

//测试函数
int main()
{
    char elements[]={'a','b','c','d','e','f','g'};
    const int N=sizeof(elements)/sizeof(elements[0]);
    int array[N]={1,1,1,0,0,0,0};
    std::vector<int> intArray(array,array+N);

    int index=0;
    do
    {
        std::cout<<++index<<" \t";
        for(size_t i=0;i<N;++i)
        {
            if(intArray[i]!=0)
                std::cout<<elements[i]<<"\t";
        }
        std::cout<<std::endl;

    }while(std::prev_permutation(intArray.begin(),intArray.end()));

    return 0;
}

执行结果：

3、用unique取出连续的空格。

例子：给定输入aa_ _ _bbb，输出aa_ bbb。

测试代码：

class BathCharAreSpces
{
public:
    operator ()(const char& a,const char& b)
{
    return a==' '&&b==' ';
}
};

//测试函数
int main()
{
    std::string testString="sadgawd    dwefdty 3er37  rt347  348y3789   y3849 ";
    std::cout<<testString<<std::endl;

    std::string::iterator last=std::unique(testString.begin(),testString.end(),BathCharAreSpces());
    testString.erase(last,testString.end());
    std::cout<<testString<<std::endl;

    return 0;
}

思路：

std::unique是去除区间中的连续的重复的元素，这道题目需要去除字符串中的空格，因此，我们只需要将“重复元素”定义为“两个元素都是空格即可”。（注意所有的针对区间的STL algorithm都只是调换区间中元素的顺序，并不删除区间中的元素）。

3、用{make,push,pop}_heap实现归并排序。

例子：给定100GB的文件，用内存为4GB的机器进行排序。

思路：

<1>先对大文件进行分块排序。比如，定义一块的大小为1GB，将大文件分割为100个小块，对每个小块文件在内存内进行排序；

<2>经过了第一步，每个小块文件自身已经是有序了，假定每个文件内部的纪录是按升序进行排列的。我们需要一个初始时有100元素的小根堆，这一百个元素排序依据是当前这一百个文件的的每个文件的首条纪录的值并且小根堆上的每个元素需要知道自身对应文件的下一条纪录，以及当前文件有没有遍历完。

<3>选取小根堆顶部的纪录写入输出文件，若小根堆顶部的纪录对应的文件还没遍历完。则将当前的小根堆的纪录置为对应的文件的下一条纪录，并对小根堆重新建堆；否则，将对顶元素删除。

<4>若当前小根堆不为空，则执行[3]，否则算法结束。

测试代码：

#include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>

typedef int Record;
typedef std::vector<Record> File;

struct Input
{
  Record value;
  size_t index;
  const File* file;

  explicit Input(const File* f)
    : value(-1),
      index(0),
      file(f)
  { }

  bool next()
  {
    if (index < file->size())
    { value = (*file)[index];
      ++index;
      return true;
    } else {
      return false;
    }
  }

  bool operator<(const Input& rhs) const
  {
    // make_heap to build min-heap, for merging
    return value > rhs.value;
  }
};

File mergeN(const std::vector<File>& files)
{
  File output;
  std::vector<Input> inputs;

  for (size_t i = 0; i < files.size(); ++i) {
    Input input(&files[i]);
    if (input.next()) {
      inputs.push_back(input);
    }
  }

  std::make_heap(inputs.begin(), inputs.end());
  while (!inputs.empty()) {
    std::pop_heap(inputs.begin(), inputs.end());
    output.push_back(inputs.back().value);

    if (inputs.back().next()) {
      std::push_heap(inputs.begin(), inputs.end());
    } else {
      inputs.pop_back();
    }
  }

  return output;
}

int main()
{
  const int kFiles = 32;
  std::vector<File> files(kFiles);
  for (int i = 0; i < kFiles; ++i) {
    File file(rand() % 1000);
    std::generate(file.begin(), file.end(), &rand);
    std::sort(file.begin(), file.end());
    files[i].swap(file);
  }

  File output = mergeN(files);

  std::copy(output.begin(), output.end(),
            std::ostream_iterator<Record>(std::cout, "\n"));
}

执行结果：

4、使用std::partition()实现元素重排。std::partition的作用是将区间中“符合条件”的元素放置在区间首部，将区间中“不符合条件”的元素放置在区间尾部。算法的时间复杂度O(N)，空间复杂度O(1)。

例子：将区间中奇数排在偶数的前面。

测试代码：


template<typename T>
void traverseEle(const std::vector<T> array)
{
    for(auto it=array.begin();it!=array.end();++it)
        std::cout<<*it<<"\t";

    std::cout<<std::endl;
}

class IsOdd
{
public:
    operator ()(int x)
{
    return x%2!=0;
}
};

//测试函数
int main()
{
    int a[]={1,2,3,4,5,6,7,8,9,0};
    const int N=sizeof(a)/sizeof(a[0]);
    std::vector<int> intArray(a,a+N);

    std::cout<<"before std::partition:\n";
    traverseEle(intArray);

    std::partition(intArray.begin(),intArray.end(),IsOdd());

    std::cout<<"after std::partition:\n";
    traverseEle(intArray);



    return 0;
}

执行结果：