Question

我想知道是否可以使用std :: sort函数对偶数或奇数进行排序。

我有以下代码，但我不确定如何在std :: sort

中实现

inline bool isEven(const Point n) {
return n.getX()%2==0;
}

这是正确的

vector<Point> c;
std::sort(c.begin(),c.end(),isEven)

请建议。

Answer 1

根据我对您的问题的理解，您希望将odd和even数字分开。如果是这种情况，std::partition就会这样做。

如果你想按升序值排序并分开odd和even个数字，我会使用类似于这段代码的东西（仍然，你必须找出你的{的哪个组成部分{1}}你想要排序）

Point

此功能可与std::sort一起使用，这是一个简短的例子：

bool sortByEven(const int& left, const int& right)
{
    if(left & 1 && right & 1) // both are odd
    {
        return left < right;
    }
    else if(left & 1) // left is odd
    {
        return false;
    }
    else if(right & 1) // right is odd
    {
        return true;
    }

    // both are even
    return left < right;
}

会给你以下输出：

std::vector<int> numbers;
numbers.push_back(-1);
numbers.push_back(5);
numbers.push_back(12);
numbers.push_back(7);
numbers.push_back(-31);
numbers.push_back(-20);
numbers.push_back(0);
numbers.push_back(41);
numbers.push_back(16);

std::sort(numbers.begin(), numbers.end(), sortByEven);

对于其他类型，只需更改-20 0 12 16 -31 -1 5 7 41或将其设为int参数

即可

Answer 2

为此，您应使用std::partition代替std::sort

vector<Point> c;
std::partition(c.begin(),c.end(),isEven)

通过排序，您通常希望排序基于任何两个元素的相对顺序。在这种情况下，您只想根据元素的固有属性对输入进行分区。这两种情况都可以减少到另一种情况，但采用直接方法总是容易一些。

Answer 3

如果查看std::sort的引用，您将看到它用于比较的函数应该采用它应该比较的两个参数。所以你的代码根本不起作用。

我建议你迭代矢量，将偶数值整理成一个临时矢量，将奇数值整理成另一个临时矢量。然后清除实际向量，并按照您喜欢的顺序附加两个临时向量。

Answer 4

您可以编写比较函数，如

bool evenOddLess( Point const& a, Point const& b )
{ return (isEven( a ) < isEven( b )); }

然后你可以将它作为std::sort的第三个参数。

Answer 5

在C＃中它更简单：

 class Program 
    {
        static void Main()
        {
          int[] numbers = { 1, 2, 3, 4, 5,6,7,8,9,10,11,12,13,14 };

         //using delegate
          Array.Sort (numbers, (x, y) => x % 2 == y % 2 ? 0 : x % 2 == 1 ? -1 : 1);

          Array.ForEach(numbers, x => Console.Write(x));
          Console.WriteLine("");

         //using custom comparer
          CustomComparer comparer = new CustomComparer();
          Array.Sort(numbers, comparer);
          Array.ForEach(numbers, x => Console.Write(x));
          Console.WriteLine("");

          //using lambda
          int[] items = numbers.OrderBy(x => x % 2 == 0).ThenBy(x => x % 2).ToArray();

          Console.WriteLine("");
          Array.ForEach(items, x => Console.Write(x));
        }

        public int Compare(int x, int y)
        {
            return x % 2 == y % 2 ? 0 : x % 2 == 1 ? -1 : 1;
        }
    }

    public class CustomComparer : IComparer<int>
    {
        int IComparer<int>.Compare(int x, int y)
        {
            return x % 2 == y % 2 ? 0 : x % 2 == 1 ? -1 : 1;
        }
    }

Answer 6

问题在于您可以使用两种功能。

$newwidth = 460;
$newheight = 275;
$newwidth1 = 146;
$newheight2 = 88;

list($width, $height) = getimagesize($path);
$src = imagecreatefromjpeg($path);
imagecopyresampled($temp, $src, 0,0,0,0, $newwidth, $newheight, $width, $height);
Imagettftext($temp, 16, 0, $start_x, $start_y, $black2, $font , "text");
imagejpeg($temp, $path,75);
imagedestroy($temp);

$temp2 = imagecreatetruecolor($newwidth1, $newheight2);
imagecopyresampled($temp2, $src, 0,0,0,0, $newwidth1, $newheight2, $width, $height);
Imagettftext($temp2, 8, 0, $start_x2, $start_y2, $black2, $font , "text");
imagejpeg($temp2,$pathFile ,75);
imagedestroy($temp2);
imagedestroy($src);

函数partition()和stable_partition()重新组织   集合的元素以所有元素的方式   哪个谓词p返回 true 将所有   哪个p返回 false 。这意味着元素将是   分为两个范围：

•[first，return_value]

•[return_value，last）

其中template< class BidirectionalIterator, class UnaryPredicate > BidirectionalIterator partition( BidirectionalIterator first, BidirectionalIterator last, UnaryPredicate p ); template< class BidirectionalIterator, class UnaryPredicate > BidirectionalIterator stable_partition( BidirectionalIterator first, BidirectionalIterator last, UnaryPredicate p );是任一函数返回的迭代器。   结果组中的元素序列在哪里   return_value和partition()不同。

stable_partition() 不保证中的任何特定订单   的范围内。

partition() 之前会保留元素的相对顺序   分裂。这意味着如果有两个元素a和b，和a   在b之前，如果它们在分裂后都属于同一组，   元素a仍将位于元素b之前。

以下是示例代码：

stable_partition()

输出：

#include <iostream> #include <algorithm> #include <vector> using namespace std; bool IsOdd(int i) { return (i & 1); //use !(i & 1); if you want to place even elements first in the vector } int main() { vector<int> v; // set some values and shuffle them: for (int i = 1; i<10; ++i) v.push_back(i); random_shuffle(v.begin(), v.end()); cout << "All elements:"; for (vector<int>::iterator it = v.begin(); it != v.end(); ++it) cout << ' ' << *it; cout << endl; //sort the vector cout << "Sorted vector:"; sort(v.begin(), v.end()); for (vector<int>::iterator it = v.begin(); it != v.end(); ++it) cout << ' ' << *it; cout << endl; //change to partition and see the difference vector<int>::iterator bound = stable_partition(v.begin(), v.end(), IsOdd); // print content: cout << "odd elements:"; for (std::vector<int>::iterator it = v.begin(); it != bound; ++it) cout << ' ' << *it; cout << endl; cout << "even elements:"; for (vector<int>::iterator it = bound; it != v.end(); ++it) cout << ' ' << *it; cout << endl; cout << "Sorted odd-even vector:"; for (vector<int>::iterator it = v.begin(); it != v.end(); ++it) cout << ' ' << *it; cout << endl; return 0; }

我希望它有助于理解。

按偶数和奇数排序

6 个答案: