精华内容
下载资源
问答
  • 如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题如题...
  • 二维向量、二维链表的输入输出

    千次阅读 2019-03-16 01:04:23
    二维向量 概述 有些朋友可能对二维数组的输出有点疑惑,因为平常遇见的少。二维是若干个一维组成的,因此借鉴一维数组的输出,可以得到二维数组的输出方法。 1. 二维链表 由于链表不像传统数组和vector,不是...

    概述

    有些朋友可能对二维数组的输出有点疑惑,因为平常遇见的少。二维是若干个一维组成的,因此借鉴一维数组的输出,可以得到二维数组的输出方法。

    1. 二维链表

    由于链表不像传统数组和vector,不是连续内存存储的,因此不能用下标运算符[ ]来索引。在输出时需要使用迭代器的指针的遍历输出。

    //声明一个二维链表
    	list<list<int>>list1;
    //声明两个一维链表,并赋值
    	list<int>list2 = { 1,2,3,4 };
    	list<int>list3 = { 2,4,6,8 };
    //将两个一维链表加入二维链表里
    	list1.push_back(list2);
    	list1.push_back(list3);
    	
    //输出二维链表的元素,注意传入参数是按值传递(不是引用传递&nums)因此在函数里对链表的修改不影响真正的链表的元素。
    void display_list_two(list<list<int>> nums) {
    	while (!nums.empty()) {
    		for (list<int>::iterator p = nums.front().begin(); p != nums.front().end(); p++) {
    			cout << *p << " ";
    		}
    		cout << endl;
    		nums.pop_front(); //将遍历完的当前一维链表删除,指针指向下一排,继续输出
    	}
    }
    

    2. 二维向量

    二维vector与二维普通数组一样有着下标运算符索引的优势,因此二维vector的输出有两种方法。

    //声明一个二维向量
    	vector<vector<int>>v1; 
    //声明两个一维向量,并赋值
    	vector<int>v2 = {1,7,8,9}; 
    	vector<int>v3 = {2,10,45,1};
    //将两个一维向量添加到二维向量里
    	v1.push_back(v2);
    	v1.push_back(v3);
    
    //输出二维向量的元素,注意传入参数是按值传递(不是&nums)因此在函数里对向量的修改不影响真正的向量的元素。
    void display_vector_two(vector<vector<int>> nums) {
    	while (!nums.empty()) {
    		for (vector<int>::iterator p = nums.front().begin(); p != nums.front().end(); p++)
    			cout << *p << " ";
    		cout << endl;
    		nums.erase(nums.begin()); //每次输出一排就删除,指针指向下一排继续输出
    	}
    }
    
    //还有一个基础的类似二维数组a[ ][ ]的输出方法,用下标运算符[ ]来输出
    void display_vector_two(vector<vector<int>> nums) {
    	for (int i = 0; i < nums.size(); i++) {
    		for (int j = 0; j < nums[i].size(); j++) {
    			cout << nums[i][j] << " ";
    		}
    		cout << endl;
    	}
    }
    
    展开全文
  • Java二维向量工具类

    2020-08-21 17:22:07
    Java自定义二维向量,实现向量之间,加减乘除,取角度等操作 /** 自定义,平面二维向量类 **/ public class Vector2D implements Cloneable { private double x; private double y; //get public double getX...

    Java自定义二维向量,实现向量之间,加减乘除,取角度等操作

    
    /**  自定义,平面二维向量类  **/
    public class Vector2D implements Cloneable {
        private double x;
        private double y;
    
    	//get
        public double getX() { return x;}
        public double getY() { return y;}
        
    	//set
        public void setX(double x) { this.x = x;}
        public void setY(double y) { this.y = y;}
    
        @Override
        public String toString() {
            return "Vector2D{" +
                    "x=" + x +
                    ", y=" + y +
                    '}';
        }
    
        /** 空构造 默认值V(x,y)=>V(0,0) **/
        public Vector2D()
        {
            x = 0;
            y = 0;
        }
    
        /** 赋值构造 V(x,y) **/
        public Vector2D(double _x, double _y)
        {
            x = _x;
            y = _y;
        }
    
        /**  获取弧度  **/
        public double getRadian()
        {
            return Math.atan2(y, x);
        }
    
        /**  获取角度  **/
        public double getAngle()
        {
            return getRadian() / Math.PI * 180;
        }
    
        /**  克隆该对象  **/
        @Override
        public Vector2D clone()
        {
            return new Vector2D(x,y);
        }
    
        public double getLength()
        {
            return Math.sqrt(getLengthSQ());
        }
    
        public double getLengthSQ()
        {
            return x * x + y * y;
        }
    
        /**  向量置零  **/
        public Vector2D Zero()
        {
            x = 0;
            y = 0;
            return this;
        }
    
        /** 该向量是否是置零的,是返回true,反之false **/
        public boolean isZero()
        {
            return x == 0 && y == 0;
        }
    
        /** 向量的长度设置为我们期待的value  **/
        public void setLength(double value)
        {
            double _angle = getAngle();
            x = Math.cos(_angle) * value;
            y = Math.sin(_angle) * value;
        }
    
        /**  向量的标准化(方向不变,长度为1)  **/
        public Vector2D normalize()
        {
            double length = getLength();
            x = x / length;
            y = y / length;
            return this;
        }
    
        /**  是否已经标准化  **/
        public boolean isNormalized()
        {
            return getLength() == 1.0;
        }
    
        /**  向量的方向翻转  **/
        public Vector2D reverse()
        {
            x = -x;
            y = -y;
            return this;
        }
    
        /**  2个向量的数量积(点积)  **/
        public double dotProduct(Vector2D v)
        {
            return x * v.x + y * v.y;
        }
    
        /**  2个向量的向量积(叉积)  **/
        public double crossProduct(Vector2D v)
        {
            return x * v.y - y * v.x;
        }
    
        /**  计算2个向量的夹角弧度  **/
        /**  参考点积公式:v1 * v2 = cos<v1,v2> * |v1| *|v2|  **/
        public static double radianBetween(Vector2D v1, Vector2D v2)
        {
            if(!v1.isNormalized()) {
                v1 = v1.clone().normalize(); // |v1| = 1
            }
            if(!v2.isNormalized()) {
                v2 = v2.clone().normalize(); // |v2| = 1
            }
            return Math.acos(v1.dotProduct(v2));
        }
    
        //弧度 = 角度乘以PI后再除以180、 推理可得弧度换算角度的公式
        /**  弧度转角度  **/
        public static double radian2Angle(double radian)
        {
            return radian / Math.PI * 180;
        }
    
        /** 向量加 **/
        public Vector2D add(Vector2D v)
        {
            return new Vector2D(x + v.x, y + v.y);
        }
    
        /** 向量减 **/
        public Vector2D subtract(Vector2D v)
        {
            return new Vector2D(x - v.x, y - v.y);
        }
    
        /** 向量乘 **/
        public Vector2D multiply(double value)
        {
            return new Vector2D(x * value, y * value);
        }
    
        /** 向量除 **/
        public Vector2D divide(double value)
        {
            return new Vector2D(x / value, y / value);
        }
    }
    
    展开全文
  • 2. 编写代码,实现二维向量和三维向量的运算: 1) 遵循软件开发标准,程序分文件书写; 2) 可以进行向量的加减和比较运算(重载+,-,=和==运算符)。 3) 分别用静态链接和共享链接的方式测试向量的使用。 3. 创建包含...
    1.#include<iostream>
    using namespace std;
    int main()
    {
      cout<<"Hello Woeld"<<endl;
    return 0;
    }
    2.vector.cxx
    #include<iostream>
    int main()
    {int k;
    char x;
    cout<<"请输入向量的维度:"<<endl;
    cin>>k;
    vector a(k),b(k),c(k);
    cout<<"请输入A向量坐标:"<<endl;
    cin>>a;
    cout<<"请输入B向量坐标:"<<endl;
    cin>>b;
    L:cout<<"请输入运算符(+,-,*,q[退出])"<<endl;
    cin>>x;
    switch(x)
    {case '+':c=a+b;break;
    case '-':c=a-b;break;
    case '*':c=a*b;break;
    case 'q':goto Z;
    default:cout<<"错误"<<endl;
    }
    cout<<"C("<<c<<")";goto L;
    Z:cout<<"按回车退出"<<endl;
    return 0;
    }
    classvector.h
    class vector
    {public:
    vector( int =1);           //默认长度构造函数
    vector(const int*,int);    //使用数组参数构造函数
    vector(const vector&);     //复制构造函数
    ~vector();                 //析构函数
    //重载运算符
    int  operator()()const;    //返回K值,即向量的维度
    vector &operator=(const vector&); 
    friend vector operator+(const vector&,const vector&);
    friend vector operator-(const vector&,const vector&);
    friend vector operator*(const vector&,const vector&);
    //重载输出输入
    friend ostream&operator<<(ostream &output,const vector&);
    friend istream&operator>>(istream &input,vector&);
    private:
    int *v;
    int len;
    };
    //构造函数     
    vector::vector(int size)//类对象初始化
    {v=new int[size];
    for(int i=0;i<size;i++) v[i]=0;
    len=size;}
    vector::vector(const int*c,int size)//用于运算 加减乘 时构造正确的vector类型对象,然后返回给main中的C,达到正确输出的目的
    {v=new int [size];
    len=size;
    for(int i=0;i<len;i++) 
    v[i]=c[i];}
    vector::vector(const vector& a)
    {len=a();
    v=new int[len];
    for(int i=0;i<len;i++)
    v[i]=a.v[i];}


    //析构函数     
    vector::~vector()
    {delete[] v;
    len=0;}
    //运算符重载     
    int vector::operator()()const//括弧:为了将main中的K值(即向量的维度)传给类当中定义为保护类型的len类成员
    {return len;}
    istream&operator>>(istream &input,vector&a)//输入
    {for(int i=0;i<a();i++)
    input>>a.v[i];
    return input;}
    ostream&operator<<(ostream &output,const vector&a)//输出
    {for(int i=0;i<a();i++)
    output<<a.v[i]<<" ";
    return output;}
    vector operator+(const vector&a,const vector&b)//加法
    { int size=a();
    int *c=new int[size];
    for(int i=0;i<size;i++)
        c[i]=a.v[i]+b.v[i]; return vector(c,size);}
    vector operator-(const vector&a,const vector&b)//减法
    { int size=a();
    int *c=new int[size];
    for(int i=0;i<size;i++)
        c[i]=a.v[i]-b.v[i];
    return vector(c,size);}
    vector operator*(const vector&a,const vector&b)//乘法
    { int size=a();
    int *c=new int[size];
    for(int i=0;i<size;i++)
        c[i]=a.v[i]*b.v[i];
    return vector(c,size);}
    vector &vector::operator=(const vector&a)//赋值号
    {int *c=new int[len];
    for(int i=0;i<len;i++)
    v[i]=a.v[i];return *this;
    }
    ubuntu@ubuntu-virtual-machine:~$ cd wx/Hello
    ubuntu@ubuntu-virtual-machine:~/wx/Hello$ g++ -E -o Hello.i Hello.cxx
    ubuntu@ubuntu-virtual-machine:~/wx/Hello$ g++ -S Hello.i -o Hello
    ubuntu@ubuntu-virtual-machine:~/wx/Hello$ g++ -c Hello.cxx
    ubuntu@ubuntu-virtual-machine:~/wx/Hello$ g++ -E -o Hello.i Hello.cxx
    ubuntu@ubuntu-virtual-machine:~/wx/Hello$ g++ Hello.o -o Hello -I ACE
    ubuntu@ubuntu-virtual-machine:~/wx/Hello$ Hello.exe
    Hello.exe: command not found
    ubuntu@ubuntu-virtual-machine:~/wx/Hello$ ./Hello
    Hello World!!
    ubuntu@ubuntu-virtual-machine:~/wx/Hello$ 
    2.(1)静态链接库:
    ubuntu@ubuntu-virtual-machine:~$ cd wx/vec1
    ubuntu@ubuntu-virtual-machine:~/wx/vec1$ make
    g++ -c  vector.cxx -o vector.o
    g++ vector.o -o vector.exe
    ubuntu@ubuntu-virtual-machine:~/wx/vec1$ ./vector.exe
    (2)动态链接库
    ubuntu@ubuntu-virtual-machine:~$ cd wx/vec2
    ubuntu@ubuntu-virtual-machine:~/wx/vec2$ make
    g++ -DDLLBUILD -c vector.cxx -o vector.o
    g++ -shared -o libvector.so vector.o
    g++ vector.o -o vector.exe
    ubuntu@ubuntu-virtual-machine:~/wx/vec2$ ./vector.exe









    展开全文
  • public class test { ... // 学会二维数组的定义,初始化,循环赋值 // 用第一种方法定义二维数组 int intArray[][]; // 用第二种方法定义二维数组 int[] intArray1[]; // 用第三种方法定义二维数...
    package com.Array;
    
    public class test {
    	public static void main(String[] args) {
    		// 学会二维数组的定义,初始化,循环赋值
    		// 用第一种方法定义二维数组
    		int intArray[][];
    		// 用第二种方法定义二维数组
    		int[] intArray1[];
    		// 用第三种方法定义二维数组
    		int[][] intArray2;
    		// 定义一个3行3列的二维数组
    		// intArray3[0][0]--->intArray3[2][2]
    		int intArray3[][] = new int[3][3];
    		//定义一个只指定行数的二维数组
    		//说明二维数组是一个特殊的一维数组,必须制定行数,而列数可以不用在初始化时指定
    		int intArray4[][]=new int[4][];
    		//每一行相当于一个一维数组,需要创建
    		intArray4[0]=new int[9];//第一行有9列
    		intArray4[1]=new int[7];//第二行有7列
    		intArray4[2]=new int[6];//第三行有6列
    		intArray4[3]=new int[2];//第四行有2列
    		//这样可以创建出一个不是正方形的二维数组,这样的二维数组一样可以使用for循环赋值
    		//只需要将具体值改为二维数组的行长度和列长度
    		
    		// 使用for循环给二维数组赋值
    		for (int i = 0; i < intArray3.length; i++) {
    			for (int j = 0; j < intArray3[i].length; j++) {
    				intArray3[i][j] = i + j;
    				System.out.print(intArray3[i][j] + "\t");
    			}
    			System.out.println();
    		}
    		System.out.println();
    		// 使用增强型循环打印二维数组(这里会输出9个奇怪的符号代码,我暂时不知道原因)
    
    		for (int i[] : intArray3) {
    			for (int n : i) {
    				System.out.print(n + "\t");
    			}
    			System.out.println();
    		}
    
    		//百度搜的怎么使用增强型for循环打印二维数组
    		/*String name[][] = { { "张三", "李四", "王五" }, { "张六", "李七", "王八" }, { "张九", "李十", "王十一" } };
    		for (String[] str1 : name) {
    			for (String str2 : str1) {
    				System.out.println(str2);
    			}
    		}*/
    
    	}
    }
    

     

    展开全文
  • 如何将二维数组赋值给vector

    千次阅读 2016-08-15 12:52:17
    vector > a; double b[10][10] = {1,2,3,4,5,6,7,8,9,,,,,,,,,,,,,,,,89,79}; 将b[10][10]值如何赋给a? 一维数组: vector a; int b[5] = {1,2,3,4,5};...二维数组: 如果a的长度给定了,  vector > a; b[5][6] =
  • Python二维数组赋值问题

    万次阅读 2018-03-30 15:29:42
    当我们采用s=[[0]*3]*2初始化一个数组,然后对s[0][0]进行赋值,改变的是第一列所有的值。因为用s = [[0]*3]*2 初始化数组,他表示的是指向这个列表的引用,所以当你修改一个值的时候,整个列表都会修改。换一种初始...
  • 二维数组(向量)中的一行(一维数组(向量))可以赋值给一个一维数组(向量)“`int main() {size_t m = 3; size_t n = 3;... //二维向量iivec.resize(m); for(size_t i = 0; i != m; ++i) iivec[i].r
  • 二维vector赋值时越界

    2018-08-28 18:07:43
  • 二维vector进行赋值

    万次阅读 2017-11-19 16:41:41
    二维vector进行赋值
  • C++ vector 实现二维数组,赋值

    万次阅读 多人点赞 2019-05-11 15:19:30
    vector二维数组赋值 vector<vector<float> >bk; vector<float> MM; MM.push_back(1); MM.push_back(22); MM.push_back(3); MM.push_back(6); bk.push_back(MM); 原文链接 (1...
  • 建了一个二维数组(19*19): ![图片说明](https://img-ask.csdn.net/upload/201806/06/1528254415_305614.png) 初始化: ![图片说明](https://img-ask.csdn.net/upload/201806/06/1528254479_16033.png) ...
  • 在网上找资料的过程中,发现并没有特别细致的讲解分类图像和分类一维向量的做法,导致我捅咕了有几天才弄明白,可能使我比较菜吧......现在在这里记录一下。 首先需要明确,前文我们已经讲解了包装数据集的方法,...
  • } } 自定义二维向量数据类型:mVector2 基于自定义浮点数据mFloat [Serializable] class mVector2 { public mFloat x; public mFloat y; public mVector2(){ this.x = new mFloat(0f); this.y = new mFloat(0f); } ...
  • (1)网上参考的三维向量类 /*-------------------------------------------------- * 类名称:三维向量类-Vector.h * 类作用:用于三维空间中向量常见的数学运算. * 创建人:Edited by huangwang * 创建...
  • 二维数组向量表示

    2017-11-14 00:55:00
    } 二维向量的输入问题: 不像二维数组那样,可以直接对arr[i][j]进行循环赋值。在vector>中,因为vector是一个容器,最外层的vector容器中放着更小的vector,而里层的vector里面放的是int型的数字。所以我们首先要...
  • 二维vector初始化,赋值

    万次阅读 2019-01-27 19:50:50
    二维vector初始化 1. 采用构造函数 vector&lt;vector&lt;int&gt;&gt; vec(10, vector&lt;int&gt;(8)); //10行8列,全部初始化为零 2.添加元素(每次添加一行) int a[] = { 1, 2, 3, 4 }; ...
  • C++中二vector赋值

    万次阅读 2018-01-09 17:09:36
    vector > nums(8,vector... //二维数组的行数为8,列数为13。后一定要加一个空格,否则会被判别为操作符>>出错 int b[8][13] = {{0,0,1,0,0,0,0,1,0,0,0,0,0}, {0,0,0,0,0,0,0,1,1,1,0,0,0}, {0,1,1,0,1,0,0,0,0,0,0
  • 维向量

    千次阅读 2011-01-10 15:19:00
    介绍了一个自定义向量
  • @python numpy 中 二维数组 转 行向量

    千次阅读 2018-11-04 21:57:43
    最近在编程过程中,想通过reshape函数将二维矩阵转换为一维数组,即一个行向量,起初通过z=Matrix.reshape(1,-1),在用z的时候总是报错,print出来发现z仍是一个二维数组,例如: Matrix=np.array([[1,2,3],[4,5,6...
  • 不多说了,RT: 代码如下: class CEDMap { private:  static const vector... <br />我希望把二维向量m_vvecGoalMap初始化为跟这个二维数组naGoalMap一样的值,请问 我该如何去实
  • 浅析连续子向量,子数组和(一维,二维)问题 By 钟桓  9月 16 2014 更新日期:9月 16 2014 文章目录 1. 最大连续子向量和 1.0.1. 问题描述: 2. 子向量和接近于03. 收费站问题4. 区间赋值问题5....
  • 在python中我们定义二维矩阵会使用 a = [[0]*5]*5 其输出结果为 如果对其某个位置上的数赋值,则 由于我们创建二维矩阵时使用了浅复制,则在赋值过程会导致当一...这种创建方式使得二维数组中的每一个行向量据定...
  • 二维数组使用memcpy赋值: //void *memcpy(void *dest, const void *src, size_t n);从源src所指的内存地址的起始位置开始拷贝n个 //字节到目标dest所指的内存地址的起始位置中。调用该函数需要引用string.h头文件...
  • 对于二维vector可以使用push_back的方法进行赋值,先push_back出一维数组,再将这个一维数组push_back进二维数组。 直接访问的vector[][]方式可以访问数组,不过不能写入数组。不过为什么我不知道(内存是怎么运行...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,064
精华内容 8,425
关键字:

二维向量赋值