精华内容
下载资源
问答
  • Vector数组排序 Vector相等比较

    千次阅读 2017-02-21 22:00:29
    最近刷题看题解遇到了vector数组排序和vector相等比较的问题。百度和谷歌了一下,发现网上没有比较好的解释,于是我自己动手实践了一下,写了一个vector数组排序和vector相等比较的实例,供大家参考。 经过验证发现...

    最近刷题看题解遇到了vector数组排序和vector相等比较的问题。百度和谷歌了一下,发现网上没有比较好的解释,于是我自己动手实践了一下,写了一个vector数组排序和vector相等比较的实例,供大家参考。
    经过验证发现,vector数组排序实质上是按照vector里的元素进行排序比较的。而vector相等比较的话,只要vector里的元素相同,这两个vector就是相等的,这一点需要特别注意一下。

    #include <iostream>
    #include<vector>
    #include<cstdio>
    #include<algorithm>
    
    using namespace std;
    vector<int> vc[6];
    
    //测试集合排序
    void vectorSort(){
        vc[1].push_back(5);
        vc[2].push_back(4);
        vc[3].push_back(3);
        vc[4].push_back(2);
        vc[5].push_back(1);
    
        sort(vc+1,vc+6);
        for(int i=1;i<6;i++){
            for(int j=0;j<vc[i].size();j++){
                printf("vc[i]:%d %d\n",i,vc[i][j]);
            }
        }
    }
    
    //测试集合相等
    void vectorSame(){
        vector<int> a,b;
        a.push_back(1);
        b.push_back(1);
        if(a==b){
            printf("is Same");
        }else{
            printf("not Same");
        }
    }
    
    int main()
    {
        vectorSort();
        vectorSame();
        return 0;
    }
    
    展开全文
  • 程序首先构建二维vector数组viA,然后对其进行打印,之后,按照不同的方式对其进行排序。 程序如下: #include <iostream> #include <vector> #include <stdlib.h> #include <algorithm> ...

    参考:使用vector创建二维动态数组,并使用sort对其进行排序

    程序首先构建二维vector数组viA,然后对其进行打印,之后,按照不同的方式对其进行排序。

    程序如下:

    #include <iostream>
    #include <vector>
    #include <stdlib.h>
    #include <algorithm>
    using namespace std;
    bool cmp(const vector<int> &a, const vector <int> &b) {
    	return a[1] > b[1];
    }
    int main()
    {
    	vector<vector<int>> viA(10);
    	for(int i = 0; i < 10; i++)
    		for(int j =0; j < 10; j++) {
    			viA[i].push_back(rand()%100);
    		}	
    	for(int i = 0; i < 10; i++) {
    		for(int j = 0; j < 10; j++) {
    			cout<<viA[i][j]<< "\t";
    		}
    		cout<<endl;
    	}
    	cout<<"排序后的输出:"<<endl;
    	for(int i = 0; i < 10; i++) {
    		//sort(viA[i].begin(), viA[i].end());
    		//sort(viA.rbegin(), viA.rend());
    		//sort(viA.begin(), viA.end(), [](const vector <int> &a, const vector <int> &b) {return a[1] < b[1];} );
    		sort(viA.begin(),viA.end(), cmp);
    	} 
    	for(int i = 0; i < 10; i++) {
    		for (int j = 0; j < 10; j++) {
    			cout<<viA[i][j]<< "\t";
    		}
    		cout<<endl;
    	}
    	return 0;
    }
    

    其中,sort(viA[i].begin(), viA[i].end())执行后,结果如下,每行都按照从小到大的顺序进行了排列。

    41      67      34      0       69      24      78      58      62      64
    5       45      81      27      61      91      95      42      27      36
    91      4       2       53      92      82      21      16      18      95
    47      26      71      38      69      12      67      99      35      94
    3       11      22      33      73      64      41      11      53      68
    47      44      62      57      37      59      23      41      29      78
    16      35      90      42      88      6       40      42      64      48
    46      5       90      29      70      50      6       1       93      48
    29      23      84      54      56      40      66      76      31      8
    44      39      26      23      37      38      18      82      29      41
    排序后的输出
    0       24      34      41      58      62      64      67      69      78
    5       27      27      36      42      45      61      81      91      95
    2       4       16      18      21      53      82      91      92      95
    12      26      35      38      47      67      69      71      94      99
    3       11      11      22      33      41      53      64      68      73
    23      29      37      41      44      47      57      59      62      78
    6       16      35      40      42      42      48      64      88      90
    1       5       6       29      46      48      50      70      90      93
    8       23      29      31      40      54      56      66      76      84
    18      23      26      29      37      38      39      41      44      82
    

    sort(viA.rbegin(), viA.rend())按照第一列元素的大小进行了排序,且是按照从大到小的顺序进行排序

    41      67      34      0       69      24      78      58      62      64
    5       45      81      27      61      91      95      42      27      36
    91      4       2       53      92      82      21      16      18      95
    47      26      71      38      69      12      67      99      35      94
    3       11      22      33      73      64      41      11      53      68
    47      44      62      57      37      59      23      41      29      78
    16      35      90      42      88      6       40      42      64      48
    46      5       90      29      70      50      6       1       93      48
    29      23      84      54      56      40      66      76      31      8
    44      39      26      23      37      38      18      82      29      41
    排序后的输出
    91      4       2       53      92      82      21      16      18      95
    47      44      62      57      37      59      23      41      29      78
    47      26      71      38      69      12      67      99      35      94
    46      5       90      29      70      50      6       1       93      48
    44      39      26      23      37      38      18      82      29      41
    41      67      34      0       69      24      78      58      62      64
    29      23      84      54      56      40      66      76      31      8
    16      35      90      42      88      6       40      42      64      48
    5       45      81      27      61      91      95      42      27      36
    3       11      22      33      73      64      41      11      53      68
    

    sort(viA.begin(), viA.end(), [](const vector &a, const vector &b) {return a[1] < b[1];} )按照第二列元素的大小进行了排序,按照从小到大的顺序排列,如果将‘a[1] < b[1]’改成‘a[1] > b[1]’就是按照从大到小的顺序排列,如果将a[1]、b[1]改成a[2]、b[2]就是按照第三列元素的大小进行排序,第三列元素所在行的其他元素随该元素整体搬移到其他行
    同样的效果还有下面这种写法:

    bool cmp(const vector<int> &a, const vector <int> &b) {
    	return a[1] < b[1];
    }
    sort(viA.begin(),viA.end(), cmp);
    

    除了普通的vector数组,pair也经常在vector中使用,相关的内容如下:pair及pair在vector中的使用

    涉及到pair的排序问题参考:vector中pair的排序方法

    展开全文
  • 直接插入法排序vector数组实现(以及"vector subscript out of range"越界问题处理)直接插入法基本原理代码段 直接插入法基本原理 在从小到大的排序过程中,设置一个哨兵位,如果a[ i ] > a[ i - 1 ](i 从 1 ...

    直接插入法排序,vector数组实现(以及"vector subscript out of range"越界问题处理)

    直接插入法基本原理

    在从小到大的排序过程中,设置一个哨兵位,如果a[ i ] > a[ i - 1 ](i 从 1 开始计数)则由哨兵位存储a[ i ]的value,此时哨兵大于a[ i - 1 ],从a[ i - 1 ]开始向前依次取a中各个元素与哨兵位比较大小,小于哨兵位的value值,则将其位置向后挪动一位,a[ i ]的值被替换为a[ i - 1]的值,以此类推…直到哨兵位不大于某个第 j 个元素时,因为此时原 j + 1的位置的值已经赋给了 j + 2位置,所以将哨兵位的value值赋值给 j + 1的位置即可
    (特殊情况是:哨兵位比任意一个前面元素都小,即在与a[ 0 ]的value值比较后发现哨兵位比它还小,此时a[ 0 ]依旧按照前面的规则向后赋值给 a[1] ,哨兵位赋值给a[ 0 ],警惕此时不要再与a[-1]作比较,由于不存在a[-1]会造成数组越界的情况导致调试中断

    代码段

    /*直接插入排序,从左到右自小而大排序,
    1) 设置哨兵,A[0]~A[n-1]存放原始数据
    2) A[0]~A[L-1]有序,如果A[L]<A[L-1],哨兵存储A[L]的值
    3) 从A[L-1]到A[0]依次与哨兵作比较,大于哨兵的往后移动
    4) 用哨兵对移动之后空出来的位置进行赋值(也就是原A[L]的值)
    5) 完成排序
    
    输入样例:38 45 26 15 77 99 6 9 78 12
    
    输出样例:6 9 12 15 26 38 45 77 78 99*/
    #include<bits\stdc++.h>
    using namespace std;
    void InsertSort(vector<int> data)//直接插入排序函数
    {
    	int shaobing;	//哨兵位
    	int j = 0;
    	for (int i = 1; i < data.size(); i++)
    	{//i 从 1 开始计数
    		shaobing = 0;//每次循环哨兵位清零
    		if (data[i] < data[i - 1])
    		{
    			shaobing = data[i];
    			j = i - 1;
    			if (j >= 0 && j < data.size())
    			{
    				for (j;  j >= 0 && j < data.size(); j--)//防止数组越界
    				{
    					if(shaobing < data[j])
                        {
    					  data[j + 1] = data[j]; 
    					}
    					else 
    					{
    						break;
    					}
    				}
    				/*
                     之前写的是:
              for(j; shaobing < data[j] && j >= 0 && j < data.size();j--)
                   {
                     data[j+1] = data[j]; 
                   }
                 //后面都一样
        但是在执行过程中报错“vector subscript out of range”,造成调试中断 
        然后进行单步调试,打开 Watch监视器
        同时去看 i、j 、data[i] 、data[j] 、data[0]到data[9](因为自己设置的测试
        样例是十位数字)
        在单步调试的过程中,发现问题出在,j--的操作执行过后,j可能出现的最小值应该
        为-1,我们原本的愿望是j出现-1之后,代表哨兵位已经小于第一位数组元素,并且
        已经将原第一位元素的值赋给第二位的位置了,此时应该跳出循环,并在跳出去以后
        将哨兵的值赋给第一位元素,即赋值给a[j + 1];
        但是在我们希望利用j小于零的条件跳出循环的时候,循环中的判断部分还有一句同
        时执行的“shaobing < data[j]”语句,即判断是否要发生向后赋值的语句,也会进
        行判断,则在j=-1的情况下发生数组越界,造成中断,报错为"vector subscript
         out of range"
        处理办法:将“shaobing < data[j]”语句拿下来在循环体中以if else语句配合
        break跳出命令的格式实现其原功能。这样在循环判断过程中就不再会出现越界的情
        况
                     */
    				if ((j+1) >= 0 && (j+1) < data.size())
    				{
    					data[j + 1] = shaobing;
    				}
    			}
    		}
    	}
    	for (int i = 0; i < data.size(); i++)
    	{
    		cout << data[i] << ' ';
    	}
    }
    int main() 
    {
    	vector <int> data;
    	int data_in;
    	while (1) 
    	{
    		cin >> data_in;
    		data.push_back(data_in);//依次输入
    		if (cin.get() == '\n') //带走回车
    		{
    			break;
    		}
    	}
    	//验证输入的正确性
    	/*for (int i = 0; i < data.size(); i++) 
    	{
    		cout << data[i]<<' ';
    	}*/
    	InsertSort(data);
    }
    

    测试样例的执行结果

    展开全文
  • vector数组元素的排序

    千次阅读 2017-04-20 23:03:34
    struct student { int sno; int descore; int caiscore; }stu; bool Sortarr( const student &a1, const student &a2) { return a1.descore > a2.descore; } int main() ... vector<student> v1;
    struct  student
    {
        int sno;
        int descore;
        int caiscore;
    }stu;
    bool Sortarr( const student &a1, const student &a2)
    {
         return a1.descore > a2.descore;
    }
    int main()
    {
        vector<student> v1;
        for (int i = 0; i < 3; i++)
        {
            cin >> stu.sno >> stu.descore >> stu.caiscore;
            v1.push_back(stu);//存入数组
        }
        sort(v1.begin(), v1.end(), Sortarr);//排序
        //排序后
        for (int i = 0; i<v1.size(); i++)
        {
            cout << v1[i].sno << " " << v1[i].descore << " " << v1[i].caiscore << endl;
        }
        return 0;
    
    }
    
    展开全文
  • 快速排序作为所有排序算法中运行速度比较快的排序算法,在程序员中广为流传,今天本文利用C++语言以及vector数组实现排序算法。 小伙伴们需要自取,有帮助的话可以点个赞~ 注:本文中提供的代码均为完整代码,放入...
  • vector数组

    2016-08-22 23:20:00
    1.Vector数组可以认为是大小的数组。 2.它可以实现排序,函数是sort(v.begin(),v.end() 。 3.它可以实现二分查找功能,函数是lower_bound(v.begin(),v.end(),x)。查找的是值x,返回第一个大于或者等于小的值的指针...
  • 问题描述:存在一个二维vector数组,例如vector&lt;vector&lt;int&gt;&gt; VIA。二维数组VIA,VIA.size() = 10,VIA[0].size() = 3;用矩阵表述就是一个十行三列的矩阵。假如数组想用第一列的数据大小...
  • 数组排序练习 vector

    2010-11-12 06:23:27
    从文件读一个数字数组排序,反序,统计出现次数
  • stl vector 数组应用

    2016-06-17 14:35:52
    #include #include #include<vector> using namespace std; void ui() { cout 欢迎进入数组操作系统" ; cout 请输入数组大小" ; } void ui2() { cout 排序" ;
  • 数组排序

    2019-09-29 10:54:34
    vector> #include <iostream> using namespace std; /* 给定一个包含1-n的数列,我们通过交换任意两个元素给数列重新排序。求最少需要多少次交换,能把数组排成按1-n递增的顺序, 其中,数组...
  • 用sort如何对一个二维数组排序,数组元素都是结构体; 我想要实现records的第二维数据按照time进行排序,如何书写sort的第三个参数 ``` struct month { string time; string status; }; struct ...
  • 可以实现生成某范围的随机数和vector数组元素随机重排排序。 用法: //加入一些噪声点 Point2f noisePoints; RandomNumber r, s;//提前设置种子 for (int i = 0; i ; i++) { noisePoints.x ...
  • 数组排序去重

    2013-04-05 11:32:36
    数组排序去重 #include #include #include #include #include using namespace std; void sort1(vectorvec) { sort(vec.begin(),vec.end()); vector::iterator iter1=unique(vec.begin(),vec.end()); vec....
  • C++和Objective-C的数组排序有什么不同呢? 说明 Objective-C的数组排序是以方法的形式来提供的,可以说很方便。而C++是以算法库来提供的, 不方便, 只能说优点就是效率高和内存利用率高. 因为C++的数组排序...
  • C++ 数组排序返回下标

    2020-09-10 10:18:38
    C++ 数组排序返回下标 # scores为std::vector<float> 型数组 std::vector<size_t> idx(scores.size()); std::iota(idx.begin(), idx.end(), 0); std::sort(idx.begin(), idx.end(), [&scores](size...
  • 题目描述 输入一颗二叉树的根节点和一个整数,打印出二叉树中...(注意: 在返回值的list中,数组长度大的数组靠前) /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(...
  • vector<int> v; int main() { int x; while(cin>>x) { v.push_back(x); } sort(v.begin(),v.end()); for(vector<int>::iterator it=v.begin(); it!=v.end(); it++) { cout<&l
  • 数组排序(二维vector

    千次阅读 2014-07-06 00:14:06
    题目要求你将 N 个部员 按照力量 从大到小 排序, 如果两个部员的力量相同, 则按照 智力 值从大到小排序, 如果两个部员力量, 智力 都一样,则按照 敏捷从 小 到 大排序。 测试数据保证没有两个部员的 力量,
  • 恢复旋转数组排序: [4,5,1,2,3] - > [1,2,3,4,5] void recoverRotatedSortedArray(vector<int> &nums) { // write your code here // 4 5 1 2 3 -> 5 4 1 2 3 -> 5 4 3 2 1 ->1 2 3 4 5 ...
  • 数组排序与查找

    2017-03-14 00:03:33
    当对数组操作需要提高效率时,先排序,后查找。 排序常用的有冒泡、快速排序、插入排序等,参见...除了常见数组,在实际工作中还可使用STL提高效率,常见有vector、list、stack、queue等,大多已集成排序、查找算法。
  • double类型数组排序

    2019-12-09 17:00:12
    vector> #include<string> #include<iostream> using namespace std; //double类型数据排序,要求时间复杂度为O(n) //O(n)复杂度的排序算法主要是计数排序、基数排序和桶排序。 //采用基数...
  • pair的动态数组排序

    2018-07-29 09:35:10
    1.pair在头文件utility中,可以有pair定义动态数组进行排序,pair中内置了&lt;的默认排序方式,即对first进行默认的升序排序,也可以通过sort函数自定义排序方式  pair的vector类型 bool strict_weak_...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,516
精华内容 2,206
关键字:

vector数组排序