向量旋转算法

最新推荐文章于 2023-12-10 16:40:57 发布
最新推荐文章于 2023-12-10 16:40:57 发布
阅读量341 收藏
点赞数
文章标签： 算法 编程 J#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zystrive/article/details/83407905
版权 
 /*
  Name: 向量旋转算法集锦 
  Copyright: 始发于goal00001111的专栏；允许自由转载，但必须注明作者和出处
  Author: goal00001111
  Date: 28-12-08 23:28
  Description: 
  向量旋转算法：将具有n个元素的向量a向左旋转r个位置。
  例如 ：将字符串"abcdefghij"旋转成"defghjabc"，其中n=10，r=3。
  其实就是将 AB 转换成 BA 的过程，这里A ="abc"， B="defghij"。
  本文总共采用了四种方法来解决向量旋转问题，依次是：
  方法一：最简单的直接移动向量旋转算法；
  方法二：简明的的逆置数组旋转算法；
  方法三：传说中的杂耍旋转算法；
  方法四：一个类似于欧几里得算法的旋转算法；
  其中方法一需要一个辅助数组，空间复杂度较高；方法二每个元素都要移动两次，效率相对较低；
  方法三和方法四都是极牛的算法，空间和时间复杂度都很低。 
  这是牛书《编程珠玑》中的一个例题，在书的网站上有详细的源码，我把它改成了我所熟悉的样子。
  源码的网站是：http://www.cs.bell-labs.com/cm/cs/pearls/code.html 
*/
#include<iostream>
#include <time.h>

using namespace std;

template <class T> //最简单的直接移动向量旋转算法
void SlideRotate(T a[], int n, int r); 

template <class T> //逆置数组的原子操作
void Reverse(T a[], int left, int right);

template <class T> //简明的的逆置数组旋转算法
void ReverseRotate(T a[], int n, int r);

int Gcd(int m, int n); //欧几里德算法求最大公约数 

template <class T> //传说中的杂耍旋转算法 
void JuggleRotate(T a[], int n, int r);

template <class T> //交换两个长度均为len的向量块a[left_1..left_1+len) 和 a[left_2..left_2+len) 
void Swap(T a[], int left_1, int left_2, int len);

template <class T> //一个类似于欧几里得算法的旋转算法
void GcdRotate(T a[], int n, int r);

template <class T> //创建一个向量 
void InitVector(T a[], int n);

template <class T> //输出一个向量 
void PrintVector(const T a[], int n);

template <class T> //判断向量旋转是否成功
bool CheckRotate(const T a[], int n, int r);

int main()
{
    const int N = 601; //测试次数 
    const int MAX = 500000; //向量长度 
    int a[MAX] = {0};
    int rotateDistance = 100000;
    time_t startTime, endTime;

   最简单的直接移动向量旋转算法///   
    time(&startTime);
    InitVector(a, MAX);
   // PrintVector(a, MAX);
    for (int i=0; i<N; i++)
        SlideRotate(a, MAX, rotateDistance); 
  //  PrintVector(a, MAX);
    if (CheckRotate(a, MAX, rotateDistance))
        cout << "True" << endl;
    else
        cout << "False" << endl;

    time(&endTime);
    cout << "time = " << difftime(endTime, startTime) << endl << endl;
    ///
    //简明的的逆置数组旋转算法//   
    time(&startTime);
    InitVector(a, MAX);
  //  PrintVector(a, MAX);
    for (int i=0; i<N; i++)
        ReverseRotate(a, MAX, rotateDistance); 
  //  PrintVector(a, MAX);
    if (CheckRotate(a, MAX, rotateDistance))
        cout << "True" << endl;
    else
        cout << "False" << endl;

    time(&endTime);
    cout << "time = " << difftime(endTime, startTime) << endl << endl;
    ///
    传说中的杂耍旋转算法 //   
    time(&startTime);
    InitVector(a, MAX);
  //  PrintVector(a, MAX);
    for (int i=0; i<N; i++)
        JuggleRotate(a, MAX, rotateDistance); 
  //  PrintVector(a, MAX);
    if (CheckRotate(a, MAX, rotateDistance))
        cout << "True" << endl;
    else
        cout << "False" << endl;

    time(&endTime);
    cout << "time = " << difftime(endTime, startTime) << endl << endl;
    ///
    /一个类似于欧几里得算法的旋转算法///   
    time(&startTime); 
    InitVector(a, MAX);
  //  PrintVector(a, MAX);
    for (int i=0; i<N; i++)
        GcdRotate(a, MAX, rotateDistance); 
  //  PrintVector(a, MAX);
    if (CheckRotate(a, MAX, rotateDistance))
        cout << "True" << endl;
    else
        cout << "False" << endl;

    time(&endTime);
    cout << "time = " << difftime(endTime, startTime) << endl << endl;
    ///

    system("pause");
    return 0;
}

方法一：创建一个长度为min{r, n-r)的辅助数组，以帮助完成旋转任务// 
/*
函数名称：SlideRotate
函数功能：最简单的直接移动向量旋转算法：先利用一个辅助数组将较短的那一段元素存储起来，
          再移动原向量中未另外存储的那部分元素，最后将辅助数组中的元素再复制到正确位置 
输入参数：T a[]：需要被旋转的向量 
          int n：向量的长度 
          int r：向量左半段长度 
输出参数：T a[]：旋转后的向量 
返回值：无 
*/
template <class T> 
void SlideRotate(T a[], int n, int r)
{    
    if (r < n - r) //如果左半段小于右半段，存储左半段的元素 
    {
        T *buf = new T[r];
        for (int i=0; i<r; i++)//存储左半段的元素 
            buf[i] = a[i];

        for (int i=r; i<n; i++)//移动右半段的元素 
            a[i-r] = a[i];

        for (int i=0; i<r; i++)//复制左半段的元素到右半段 
            a[n-r+i] = buf[i];

        delete []buf;  
    }
    else //否则存储右半段的元素  
    {
        T *buf = new T[n-r];
        for (int i=r; i<n; i++)//存储右半段的元素 
            buf[i-r] = a[i];

        for (int i=r-1; i>=0; i--)//移动左半段的元素 
            a[i+n-r] = a[i];

        for (int i=0; i<n-r; i++)//复制右半段的元素到左半段 
            a[i] = buf[i];

        delete []buf; 
    }
}

//方法二：使用一个逆置数组的原子操作 
/*
函数名称：Reverse
函数功能：逆置数组的原子操作 
输入参数：T a[]：需要被逆置的向量  
          int left： 数组的左界 
          int right：数组的右界 
输出参数：T a[]：逆置后的数组 
返回值：无 
*/
template <class T> 
void Reverse(T a[], int left, int right)
{    
    T t; 
    while (left < right) 
    {
        t = a[left]; 
        a[left] = a[right]; 
        a[right] = t;
        left++;
        right--;
    } 
}

/*
函数名称：ReverseRotate
函数功能：简明的的逆置数组旋转算法：构造一个逆置数组的原子操作子函数，然后设置不同的数组左右界，
          分三次调用子函数就行了。因为每个元素都需要移动两次，所以效率不是很高。 
输入参数：T a[]：需要被旋转的向量 
          int n：向量的长度 
          int r：向量左半段长度 
输出参数：T a[]：旋转后的向量 
返回值：无 
*/
template <class T> 
void ReverseRotate(T a[], int n, int r)
{    
    Reverse(a, 0, r-1); //逆置左半段数组
    Reverse(a, r, n-1); //逆置右半段数组 
    Reverse(a, 0, n-1); //逆置整段数组 
}

//方法三：传说中的杂耍旋转算法

/*
函数名称：Gcd
函数功能：欧几里德算法求最大公约数 
输入参数：int m：正整数之一 
          int n：正整数之二 
输出参数：无
返回值：正整数m和n的最大公约数 
*/
int Gcd(int m, int n)
{    
    int t;
    while (m > 0) 
    {
        t = n % m;
        n = m;
        m = t;
    }
    return n;
}

/*
函数名称：JuggleRotate
函数功能：传说中的杂耍旋转算法：
          先将a[0]存储到临时变量t中，然后将a[r]移动到a[0],将a[2r] 移动到 a[r]，
          依此类推(数组中所有的下标都要对数组的长度n取模)，直到(k*r)%n == 0，
          此时我们不能在a[0]中取数，而是在临时变量t中取数，然后结束该过程。
          如果该过程不能移动所有的元素，那么我们从a[1]开始移动，一直依次下去，
          直到移动了所有的元素为止。
          那么总共要重复开始移动几次呢？数学证明是Gcd(r, n)次。 
          此算法每个元素只需移动一次就可以到达正确位置，理论上效率是最高的，
          但由于要做求最大公约数和求余运算等准备工作，所以没有显示出优势。 
输入参数：T a[]：需要被旋转的向量 
          int n：向量的长度 
          int r：向量左半段长度 
输出参数：T a[]：旋转后的向量 
返回值：无 
*/
template <class T> 
void JuggleRotate(T a[], int n, int r)
{    
    int i, j, k;
    int cyc = Gcd(r, n); //用r和n的最大公约数作为循环周期

    for (i=0; i<cyc; i++) //总共需要重复开始移动cyc次，才能使得所有的元素都移动到正确位置 
    {
        T t = a[i]; //临时变量t存储a[i] 
        j = i;
        while (1)//依次移动元素，直到 (k*r)%n == 0
        {
            k = j + r;
            if (k >= n) //用除法运算替代模运算 
                k -= n;

            if (k == i)
                break;
            a[j] = a[k]; 
            j = k;
        }
        a[j] = t; 
    }
}

//方法四：一个类似于欧几里得辗转相除算法的旋转算法/
/*
函数名称：Swap
函数功能：交换两个长度均为len的向量块a[left_1..left_1+len) 和 a[left_2..left_2+len) 
输入参数：T a[]：需要被处理的向量 
          int left_1：向量块a[left_1..left_1+len)的左界 
          int left_2：向量块a[left_2..left_2+len)的左界 
          int len： 两个向量块的长度
输出参数：T a[]：交换了部分元素的向量 
返回值：无 
*/
template <class T> 
void Swap(T a[], int left_1, int left_2, int len)
{    
    T t; 
    while (len > 0) 
    {
        t = a[left_1]; 
        a[left_1] = a[left_2]; 
        a[left_2] = t;
        left_1++;
        left_2++;
        len--;
    } 
}

/*
函数名称：JuggleRotate
函数功能：一个类似于欧几里得辗转相除算法的旋转算法：
          就像一个做阻尼振动的弹簧振子一样，按照由两边到中间的顺序，整段的交换向量块，
          并且被交换的向量块长度不断缩减，直到lLen == rLen。
          由于重复移动的元素较少，所以效率比逆置数组旋转算法要高。 
输入参数：T a[]：需要被旋转的向量 
          int n：向量的长度 
          int r：向量左半段长度 
输出参数：T a[]：旋转后的向量 
返回值：无 
*/
template <class T> 
void GcdRotate(T a[], int n, int r)
{    
    if (r == 0 || r == n) //特殊情况不用旋转 
        return;

    int lLen, rLen, pos;    
    lLen = pos = r;
    rLen = n - r;
    while (lLen != rLen) 
    {
        if (lLen > rLen) //左半段大于右半段，移动右半段 
        {
            Swap(a, pos-lLen, pos, rLen);
            lLen -= rLen; //减少移动范围 
        } 
        else 
        {
            Swap(a, pos-lLen, pos+rLen-lLen, lLen);
            rLen -= lLen;
        }
    }
    Swap(a, pos-lLen, pos, lLen); //最后交换中间段 
}

/*
函数名称：InitVector
函数功能：创建一个向量 
输入参数：T a[]：需要被赋值的向量 
          int n：向量的长度 
输出参数：T a[]：创建好的向量 
返回值：无 
*/
template <class T> 
void InitVector(T a[], int n)
{
    for (int i=0; i<n; i++) //创建一个向量 
        a[i] = i;
}

/*
函数名称：PrintVector
函数功能：输出一个向量 
输入参数：const T a[]：需要被输出的向量 
          int n：向量的长度 
输出参数：无
返回值：无 
*/
template <class T> 
void PrintVector(const T a[], int n)
{
    for (int i=0; i<n; i++) 
        cout << a[i] << ' ';
    cout << endl;   
}

/*
函数名称：CheckRotate
函数功能：判断向量旋转是否成功 
输入参数：T a[]：需要被旋转的向量 
          int n：向量的长度 
          int r：向量左半段长度 
输出参数：无
返回值：旋转成功返回true，否则返回false 
*/
template <class T> 
bool CheckRotate(const T a[], int n, int r)
{    
    for (int i=0; i<n-r; i++) //判断左半段 
    {
        if (a[i] != i+r)
            return false;
    }

    for (int i=0; i<r; i++)//判断右半段 
    {
        if (a[n-r+i] != i)
            return false;
    }

    return true;
}
zystrive
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ie 滤镜 向量旋转公式:
OnePiece
07-16 884
在二维坐标系中，一个位置向量的旋转公式可以由三角函数的几何意义推出。 向左转|向右转 比如上图所示是位置向量R逆时针旋转角度B前后的情况。 在左图中，我们有关系： 　　x0 = |R| * cosA => cosA = x0 / |R| 　　y0 = |R| * sinA => sinA = y0 / |R| 　在右图
向量旋转算法集锦
goal00001111的专栏
12-29 2163
 /*  Name: 向量旋转算法集锦   Copyright: 始发于goal00001111的专栏；允许自由转载，但必须注明作者和出处  Author: goal00001111  Date: 28-12-08 23:28  Description:   向量旋转算法：将具有n个元素的向量a向左旋转r个位置。  例如 ：将字符串"abcdefghij"旋转成"defghjabc"，其中n=10
向量旋转
Liuwenhao866595的专栏
06-19 741
  本文先发布于：http://coderbee.net/index.php/algorithm/20130619/224   向量旋转 题目均来自《编程珠玑》，代码实现是用Go语言。   题 将一个n元一维向量向左旋转（循环移位）i个位置。例如，当n=8时且i=3时，向量abcdefgh旋转为defghabc。简单的代码使用一个n元的中间向量在n步内完成该工作。能否仅用数十...
向量旋转问题
lxmky的专栏
09-02 1044
问题： 《编程珠玑》里面典型的向量旋转问题。 分析： 直接转载的，认为写的比较好 -------------------------------------------------------- 问题描述如下：Rotate vector x[n] left by d positions. 把x[n]向左旋转d个位置。 例如：当n=8, d=3, 把abcdefgh向左旋转3
C++实现一维向量旋转算法
01-01
在《编程珠玑》一书的第二章提到了n元一维向量旋转算法（又称数组循环移位算法）的五种思路，并且比较了它们在时间和空间性能上的区别和优劣。本文将就这一算法做较为深入的分析。具体如下所示： 一、问题描述 将一...
11_MUSIC算法_matlab向量旋转_music_
10-01
matlab算法，music算法，计算空间谱密度与旋转坐标向量，阵列信号处理
旋转人脸检测算法.pdf
05-11
"旋转人脸检测算法" 旋转人脸检测算法是一种用于人脸检测的算法，它可以检测旋转的人脸，并对其进行分类和定位。该算法使用RIOU（Rotation-based Intersection over Union）指标来计算预选框和真实值之间的重合程度...
旋转向量解法（罗德里格公式推导及理解）
weixin_39984672的博客
08-25 4793
在计算机图形学里，我们时常有这种需求，求一个向量绕任意轴旋转θ后的向量是多少。我们可以使用罗德里格公式解得。 罗德里格公式： 其中，θ为旋转角度，V为待旋转向量，K为旋转轴（单位向量），为旋转后的向量。 （上图来自百度） 推导： 先看图，v为待旋转向量，k为旋转轴，为与k平行的v分量，为与k垂直的v分量，、、v、k在同一平面上（由v和k确定的平面），w是该平面的法向量。是旋转后的向量...
N维空间中的旋转方法（仅是数学推导，不是代码）
06-28
任意维数欧氏空间中的旋转矩阵推导。可以用作高维数据处理的快速算法。 注意：不是主轴化算法！不是主轴化算法！不是主轴化算法！ 只有数学理论，没有代码，没有代码，没有代码。
一种另类的计算向量旋转公式（复杂慎用）
weixin_30576827的博客
08-29 249
　　一般来说，我们解决向量旋转问题一般要么是用旋转矩阵，要么是用四元数。但很早以前我从网上找了一种比较另类的函数，当时也没有深究。最近又把这个函数拿出看看，仔细一琢磨，发现真的很另类。这里分享一下，就当是扩展一下思维。这个旋转方法据说叫Rodrigues旋转公式。 　　这个方法的公式是这样的，P'=P·cosθ+(A×P)sinθ+A(A·P)(1-cosθ)。这种公式任谁第...
旋转向量方法的一些学习
草头菜的博客
12-01 806
最近也没闲着，上次学习了SuperSort之后，（书上好像叫做“位图方法”），顺便去复习了一下常规的排序算法，现在基本上都过了一遍，代码也差不多写完了，准备再整理整理过两天发上来，其实有这么写博客挺好的，写下来以后就不用在去自己的电脑里找了，而且写博客的过程也是对知识的一个提炼和复习，当然，还是那句话，本人菜鸟，欢迎拍砖，争取早日实现博客评论的零记录。好，言归正传：给定一个字符串诸如“abcdefg”,然后要求向左移动三位，即得到“defgabc”这样的结果，当然前提是不使用现成的方法，而且书中还要求是只能
旋转的多维空间图形
学习的最佳方式，就是把它写下来!
08-21 1267
可以旋转的四面体和立方体 public class MyRenderer implements Renderer {     float[] taperVertices = new float[] {               0.0f, 0.5f, 0.0f,               -0.5f, -0.5f,-0.2f,               0.5f, -0.
leetcode 396. Rotate Function 旋转向量的计算 + 寻找规律
JackZhangNJU的专栏
12-06 222
Given an array of integers A and let n to be its length. Assume Bk to be an array obtained by rotating the array A k positions clock-wise, we define a “rotation function” F on A as follow: F(k) = 0
虚幻 蓝图 利用X创建旋转
最新发布
qq_15132803的博客
12-10 106
刚接触一头雾水没明白啥意思，其实很简单，以利用X创建旋转为例，此节点接收一个向量，然后返回将X轴与此向量对齐后的旋转角度。而利用XY创建旋转则是以X向量为准，Y向量作为参考返回将X轴对齐到X向量，Y轴对齐到Y向量后的旋转角度，其他几个节点可以以此类推。2.利用XY创建旋转。3.利用XZ创建旋转。5.利用YX创建旋转。6.利用YZ创建旋转。8.利用ZX创建旋转。9.利用ZY创建旋转。
三维空间中的旋转--旋转向量
lwjaiyjk3的专栏
07-03 8757
处理三维旋转问题时，通常采用旋转矩阵的方式来描述。一个向量乘以旋转矩阵等价于向量以某种方式进行旋转。除了采用旋转矩阵描述外，还可以用旋转向量来描述旋转，旋转向量的长度（模）表示绕轴逆时针旋转的角度（弧度）。旋转向量与旋转矩阵可以通过罗德里格斯（Rodrigues）变换进行转换。 OpenCV实现Rodrigues变换的函数为 int cvRodrigues2(
向量旋转公式
qq_23158477的博客
01-17 2394
在二维坐标系中，一个位置向量的旋转公式可以由三角函数的几何意义推出。 比如上图所示是位置向量R逆时针旋转角度B前后的情况。 在左图中，我们有关系： 　　x0 = |R| * cosA => cosA = x0 / |R| 　　y0 = |R| * sinA => sinA = y0 / |R| 　在右图中，我们有关系： 　　x1 = |R| * cos（A+B） 　　y1 = |R| * sin（A+B）...
三维空间中向量的旋转
nnzzll的博客
05-20 9422
三维空间中向量的旋转
马特塞特旋转演算法的实现
05-24
马特塞特旋转演算法（Matrices rotation algorithm）可以用来求解对称矩阵的特征值和特征向量。其基本思想是通过旋转矩阵相似变换将对称矩阵转换为对角矩阵。以下是一个简单的 Python 实现： ```python import ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值