C++ 给定整数系列，提供第k个最大数_C++

C++ 给定整数系列，提供第k个最大数

c++

C++ 给定整数系列，提供第k个最大数,c++,C++,请帮助我找出algo2（）函数的错误。算法2的过程如下：将N个数字读入向量按降序排列向量元素将逐个读取剩余的每个元素当新元素到达时，如果它小于向量中的第k个元素，则忽略它否则，它将被放置在数组中正确的位置，将一个元素从向量中剔除最后，将打印第k个位置的元素我已经尽力了；但每次我执行algo2（）函数时，它都会停止执行。非常感谢你的帮助。多谢各位 #include <iostream> #include <stdlib.h> #i

请帮助我找出algo2（）函数的错误。算法2的过程如下：

将N个数字读入向量
按降序排列向量元素
将逐个读取剩余的每个元素
当新元素到达时，如果它小于向量中的第k个元素，则忽略它
否则，它将被放置在数组中正确的位置，将一个元素从向量中剔除
最后，将打印第k个位置的元素

我已经尽力了；但每次我执行algo2（）函数时，它都会停止执行。非常感谢你的帮助。多谢各位

    #include <iostream>
    #include <stdlib.h>
    #include <math.h>
    #include <vector>

    using namespace std;

    vector<int> input()
    {
        vector<int> nums;
        int input;

        cout << "Please enter some integers (type 12345 to end):\n";
        do 
        {
            cin >> input;
            nums.push_back(input);
        }
        while(input!=12345);
        nums.pop_back(); //omits terminator value from the vector

        return nums;
    }

    vector<int> sorter(vector<int> nums,int ilan)
    {
        int index,ctr;
        for(ctr=1;ctr<=pow((ilan-1),2);ctr++)
        {
            for(index=1;index<ilan;index++)
            {
                if(nums[index]>nums[index-1])
                {
                    nums[index]+=nums[index-1];
                    nums[index-1]=nums[index]-nums[index-1];
                    nums[index]-=nums[index-1];
                }
            }
        }
        return nums;
    }

    void cardinal(int k)
    {
        if(k==11||k==12||k==13)
            cout << "th";
        else
        {
            while(k>10)
            {
                k=k%10;
            }
            switch(k)
            {
                case 1: {cout << "st"; break;}
                case 2: {cout << "nd"; break;}
                case 3: {cout << "rd"; break;}
                default: cout << "th";
            }
        }
    }

    void output(vector<int> nums,int k)
    {
        cout << "The " << k;
        cardinal(k);
        cout << " largest number is " << nums[k-1];
    }

    void algo2(vector<int> nums,int k)
    {
        int index;
        int cursor;
        nums = sorter(nums,k);
        for(cursor=k;cursor+1<nums.size();)
        {
            if(nums[k-1]<nums[cursor])
            {
                for(index=0;index<(k-1);index++)
                {
                    if(nums[cursor]>nums[index])
                    {
                        nums.insert(nums.begin()+index,nums[cursor]);
                        if(k+2==nums.size())
                            nums.erase(nums.begin()+k+1);
                        else
                            nums.erase(nums.begin()+k,nums.begin()+k+1);
                        break;
                    }   
                }
            }
            else
            {
                nums.erase(nums.begin()+cursor);
                break;
            }
        }
        output(nums,k);
    }

    int main()
    {
        vector<int> nums;
        int choice=0, k=0;

        cout << "Type the algorithm number you'll use (1 or 2): ";
        cin >> choice;
        cout << "Input k: ";
        cin >> k;

        //Algorithm 1
        if(choice==1)
        {
            nums = input();
            nums = sorter(nums,nums.size());
            output(nums,k);
        }
        //Algorithm 2
        else if(choice==2)
        {
            nums = input();
            algo2(nums,k);
        }

        cout << endl << endl;
        system("pause");
        return 0;
    }

#包括
#包括
#包括
#包括
使用名称空间std；
向量输入（）
{
向量nums；
int输入；
cout>输入；
nums.推回（输入）；
}
while（输入=12345）；
nums.pop_back（）//从向量中忽略终止符值
返回nums；
}
向量分类器（向量nums，国际米兰）
{
国际指数；
对于（ctr=1；ctr这是工作代码。您需要删除正在考虑的元素
快速要点：
您的分拣工作正常，但我将其更改为我熟悉的方式。忽略分拣机功能的更改。
专注于algo2函数
#include <iostream>
#include <stdlib.h>
#include <math.h>
#include<conio.h>
#include <vector>

using namespace std;

vector<int> input()
{
    vector<int> nums;
    int input;

    cout << "Please enter some integers (type 12345 to end):\n";
    do 
    {
        cin >> input;
        nums.push_back(input);
    }
    while(input!=12345);
    nums.pop_back(); //omits terminator value from the vector

    return nums;
}

vector<int> sorter(vector<int> nums,int ilan)
{
    int index,ctr;
    for(ctr=0;ctr<ilan;ctr++)
    {
        for(index=ctr+1;index<ilan;index++)
        {
            if(nums[index]>nums[index-1])
            {
                nums[index]+=nums[index-1];
                nums[index-1]=nums[index]-nums[index-1];
                nums[index]-=nums[index-1];
            }
        }
    }
    cout<<"\n";
    for(int i=0;i<ilan;i++)
     cout<<nums[i]<<" ";
    getch(); 
    return nums;
}

void cardinal(int k)
{
    if(k==11||k==12||k==13)
        cout << "th";
    else
    {
        while(k>10)
        {
            k=k%10;
        }
        switch(k)
        {
            case 1: {cout << "st"; break;}
            case 2: {cout << "nd"; break;}
            case 3: {cout << "rd"; break;}
            default: cout << "th";
        }
    }
}

void output(vector<int> nums,int k)
{
    cout << "The " << k;
    cardinal(k);
    cout << " largest number is " << nums[k-1];
}

void algo2(vector<int> nums,int k)
{
    int index;
    int cursor;
    nums = sorter(nums,k);
    while(k<nums.size())
    {
        int t=nums[k];
        nums.erase(nums.begin()+k);                
        if(nums[k-1]<t)
        {
            for(index=0;index<=(k-1);index++)
            {
                if(t>nums[index])
                {
                    nums.insert(nums.begin()+index,t);
                    nums.erase(nums.begin()+k);
                    break;
                }   
            }
        }
    }
    output(nums,k);
}

int main()
{
    vector<int> nums;
    int choice=0, k=0;

    cout << "Type the algorithm number you'll use (1 or 2): ";
    cin >> choice;
    cout << "Input k: ";
    cin >> k;

    //Algorithm 1
    if(choice==1)
    {
        nums = input();
        nums = sorter(nums,nums.size());
        output(nums,k);
    }
    //Algorithm 2
    else if(choice==2)
    {
        nums = input();
        algo2(nums,k);
    }

    cout << endl << endl;
    system("pause");
    return 0;
}

#包括
#包括
#包括
#包括
#包括
使用名称空间std；
向量输入（）
{
向量nums；
int输入；
cout>输入；
nums.推回（输入）；
}
while（输入=12345）；
nums.pop_back（）；//从向量中忽略终止符值
返回nums；
}
向量分类器（向量nums，国际米兰）
{
国际指数；
对于（ctr=0；ctr我认为这是找到第k个最大数的最佳方法
#include "stdafx.h"
#include <iostream>
#include <algorithm>
using namespace std;

int partion(int arr[], int left, int right)
{
    int i = left;
    int j = right;
    int target = arr[i];

    while (i < j)
    {
        if (arr[j] > target)
            j--;
        arr[i] = arr[j];

        if (arr[i] <= target)
            i++;
        arr[j] = arr[i];
    }
    arr[j] = target;
    return j;
}


void quickSort(int arr[], int start, int end)
{
    if(start >= end)
        return;

    int pos = partion(arr, start, end);

    quickSort(arr, start, pos);
    quickSort(arr, pos+1, end);
}

int kth_element(int arr[], int start, int end, int k)
{
    int pos = partion(arr, start, end);
    if (pos == k)
        return arr[pos];
    else if (pos < k)
        kth_element(arr, pos + 1, end, k);
    else
        kth_element(arr, start, pos, k);
}
struct print
{
    void operator()(int a)
    {
        cout<<a<<" ";
    }
};
int main()
{
    int arr[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
    int len = sizeof(arr) / sizeof(*arr);

    quickSort(arr, 0, len - 1);

    for_each(arr, arr + len, print());
    cout<<endl;

    cout<<"k = 2:  "<<kth_element(arr, 0, len - 1, len - 2)<<endl;
}

#包括“stdafx.h”
#包括
#包括
使用名称空间std；
整数分割（整数arr[]，整数左，整数右）
{
int i=左；
int j=右；
int target=arr[i]；
而（i目标）
j--；
arr[i]=arr[j]；
如果（arr[i]=结束）
返回；
int pos=部分（arr、开始、结束）；
快速排序（arr、start、pos）；
快速排序（arr，位置+1，结束）；
}
int-kth_元素（int-arr[]，int-start，int-end，int-k）
{
int pos=部分（arr、开始、结束）；
如果（pos==k）
返回arr[pos]；
否则如果（位置cout好的，我现在发现了问题：
如果发现较大的元素，请将其插入向量中的适当位置，然后从第一个k
中删除最小的元素，该元素现在位于k
位置。到目前为止，还可以。但是，您不会从向量的其余部分删除刚插入的元素。因此，在下一次迭代中它会再次找到同一个元素，因为如果元素等于找到的元素，你也会这样做，结果是一个无休止的循环
无论如何，这里有一个算法，它在校正后基本上与您的算法相同，但它利用了标准库设施（当然，除了利用预先制作的n_元素
算法：-）之外）。另一个更改是我添加了一些错误检查。我没有更改的是，您的算法执行输出。通常，算法应该只返回其结果，并将其留给调用方如何处理
void algo2_improved(std::vector<int> num, int k)
{
  if (num.size() < k)
  {
    std::cout << "there are too few elements in the vector!\n";
    return;
  }

  std::sort(num.begin(), num.begin()+k, std::greater<int>());

  while (num.size() > k)
  {
    if (num[k] >= num[k-1])
      std::rotate(std::upper_bound(num.begin(),
                                   num_begin()+k,
                                   num[k],
                                   std::greater<int>()),
                  num.begin()+k,
                  num.begin()+k+1);
    num.erase(num.begin()+k);
  }
  output(num, k);
}

改进的void算法（std:：vector num，int k）
{
if（num.size（）=num[k-1]）
std:：rotate（std:：上限（num.begin（）），
num_begin（）+k，
num[k]，
std:：greater（）），
num.begin（）+k，
开始次数（）+k+1）；
num.erase（num.begin（）+k）；
}
输出（num，k）；
}
它在哪里“停止执行”？你已经做了什么来找到这个bug？你知道有一个内置的排序函数，对吗？我不能确定你更新变量光标的位置。照现在的情况，它似乎是固定在索引k
@Christian Severin，当我完成输入12345作为终止符时，它停止执行。@Aravind，我知道有一个内置的但是我的教授说我们应该使用循环结构手动排序。在sorter函数中，为什么需要打印向量的迭代内容（直到k）？您在algo2（）中所做的修改函数，如果忽略分拣机函数的输出，恕我直言，我认为修改后的程序的输出有问题。我需要用户输入的序列中第k个最大的数字。例如，如果我输入数字1、2、3、4和5，并且我的k等于2，它应该给我元素的结果：4。是的呃，对不起，我正在修复它。请稍候。我已经更新了代码。如果你有更多问题，请询问。太好了！！！真的太好了！它正在工作。我只能通过一句感谢的话来报答你。你救了我一天。我从过去5个小时就一直在做这件事，我被卡住了。非常感谢你的时间和努力！为什么当给定int时会这样egers是6，25，3，0，-9，10，8，4和1；如果k=5，那么第五大数字是3？（应该是4）由于他的tast可能不是排序算法，因此最好的方法不是自行编写的快速排序，而是标准函数std:：sort
，通过对快速排序算法进行所有众所周知的改进，并采用更好的枢轴元素（可能是三个中位数），几乎肯定会更有效。我明白了。这就是原因。谢谢：）@NykerKing：注意我的编辑，它给出了实现相同算法的改进代码。n\u元素
是t