今天微软面试的一道算法题。求各位帮忙解决。！

[蔡袅]

给定方法签名：

MoveSubArrayToTheEnd(int[] array, int numberOfElements) 

传入一个数组如 {1,2,3,4,5,6,7}
将数组前面 head的一个子集移到数组末尾end
如input numberOfElements=3，则{1,2,3,4,5,6,7}=>{4,5,6,7,1,2,3}
input numberOfElements=5，则{1,2,3,4,5,6,7}=>{6,7,1,2,3,4,5}
如何写出该算法？

我没完整正确的写出来。请不要使用FCL提供的类库函数。。

[ailin84]

微软面试题? 这是教科书上面的题目的吧

那本书好像叫分析和算法,第一个例子就是

[ailin84]

目前效率最高的算法就是数组倒排序的方式,将数组一分为2 完成3次倒排序即可实现

[yoyo_573]

[Quote=引用 32 楼 gomoku 的回复:]
C# code


// 假设^表示逆序
// A = (1,2,3) A^ = (3,2,1)
// B = (4,5,6,7) B^ = (7,6,5,4)
// 则：
// AB = (1,2,3)(4,5,6,7)
// (A^B^)^ = BA = (4,5,6,7)(1,2,3)
//
void MoveSubArrayToTheEnd(int[] arra……
[/Quote]


高手这是不一样

[tracylane]

佩服佩服！

[完美算法]

input numberOfElements=3，则{1,2,3,4,5,6,7}=>{4,5,6,7,1,2,3}

        static void Main(string[] args)
        {
           
            int[] intList = { 1, 2, 3, 4, 5, 6, 7};
            int number =3;           

            int intLength = intList.Length;//获取数组的元素总数
            int[] listTemp = new int[intLength];//新建一个和intList元素数一样的空数组        

            int k = 0;
            for (int i = 0; i < intLength; i++)
            {
                if (i < intLength - number)
                {
                    listTemp[i] = intList[number + i];
                    k--;//每次都减少1，使下下面的intList从0开始，
                }
                else
                {
                    listTemp[i] = intList[k + i];                     
                }

            }
            string str = "";
            foreach (var item in listTemp)
            {
                str = str + item.ToString();
            }

            Console.WriteLine(str);
            Console.ReadKey();

        }

[回忆是抓不到的月光]

int[] arr = new int[] { 1, 2, 3, 4, 5, 6, 7 };
int par = 4;
    
int lst = arr.Length - 1;

int t = 0;            
while (par > 1)            
{                
t ^= arr[lst];                
arr[lst] ^= t;                
t ^= arr[lst];                
for (int i = 0; i <= lst; i++)                
{                    
t ^= arr[i];                    
arr[i] ^= t;                    
t ^= arr[i];                
}                
par--;            
}

[回忆是抓不到的月光]

int[] arr = new int[] { 1, 2, 3, 4, 5, 6, 7 };
int par = 4;
    
int lst = arr.Length - 1;

int t = 0;            
while (par > 1)            
{                
    t ^= arr[lst];                
    arr[lst] ^= t;                
    t ^= arr[lst];                
    for (int i = 0; i <= lst; i++)                
    {                    
        t ^= arr[i];                    
        arr[i] ^= t;                    
        t ^= arr[i];                
    }                
    par--;            
}

[jstar920]

牛!
BA = (A'B')'

[Quote=引用 14 楼 juwendchris 的回复:]

前半部倒置，后半部倒置，再整个倒置，代码回去在弄，上课中。。。
用的是BA=(A倒置B倒置)倒置
[/Quote]

[jstar920]

如果: input numberOfElements=4，array = {1,2,3,4,5,6,7}

1 2 3 4, 5 6 7.
1,5 6 7. 2 3 4
,7 5 6.1 2 3 4

,表示n的位置
感觉好像行不通


[Quote=引用 7 楼 yxw545061402 的回复:]

前面要出一点小问题，之前判断以下n是否》numberOfElements/2,大于用上方法
如果小于，那就倒过来看待，是一样的，逻辑反正就是这样的了
[/Quote]

[liuyonghong159632]

我有两个算法 第一个 无意间发现的 无需添加新数组 很牛逼的算法，第二个自己写得！
测试结果 错不了.........
void MoveSubArrayToTheEnd(int[] array, int numberOfElements)
{
int l = array.Length, n = numberOfElements % l, temp = 0;
for (int i = 0, x = 0, y = 0; i < l; i++, y += n, x = (x - n + (y % l + l - 1) / l - 1 + l) % l)
{
int t = array[x];
array[x] = y % l == 0 ? array[(x + n) % l] : temp;
temp = t;
}
}

int[] MoveSubArrayToTheEnd2(int[] array, int n)
{
n = n % array.Length;
int[] ary = new int[array.Length];
for (int i = n ; i < array.Length; i++)
{
ary[i-n] = array[i];
}
for (int i = 0; i < n; i++)
{
ary[n+i] = array[i];
}
return ary;
}

[qq120848369]

分别翻转，然后整体翻转，好幼稚。

[liujianzhueric0535]

思路：将关键元素前面的数赋给一个新的数组，然后将关键元素后面的数移到数组前面，然后再将新数组的元素追加到原始数组中
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace CSDN求解
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("输入数组长度:");
int n = int.Parse(Console.ReadLine());
int [] array=new int[n];
for (int i = 0; i < n; i++)
{
array[i] = int.Parse(Console.ReadLine());
}
Console.WriteLine("输入的数组为：");
foreach (int o in array) //输出新数组的元素
{
Console.Write(" {0} ",o);
}
Console.WriteLine();
int numberOfElements = int.Parse(Console.ReadLine());//请输入关键元素
MoveSubArrayToTheEnd(array, numberOfElements);//调用函数实现数组头部整体移动到关键元素的后边形成新的数组

Console.ReadLine();
}
public static void MoveSubArrayToTheEnd(int[] array, int numberOfElements)
{
//思路在关键字处将一维数组拆分，形成两个新的数组，然后再将两个数组连接成一个新的数组,即所求数组！
int flag=0;
int sign = 0;
int j2 = 0;
for (int j = 0; j < array.Length; j++)
{
if (array[j] == numberOfElements)
flag = j+1;
else
;
}
Console.WriteLine("关键元素的位置是:{0}", flag);
//int x2 = int.Parse(Console.ReadLine());

Console.WriteLine("数组s1：");
int[] s1 = new int[flag];
for (int j1 = 0; j1 < flag ; j1++)//将array中关键元素之前的元素赋给一个新的数组
{
s1[j1] = array[j1];

}
foreach (int o in s1) //输出新数组的元素
{
Console.WriteLine(o);
}
for (j2 = 0; j2 < array.Length-s1.Length; j2++)
{
array[j2]=array[flag+j2];
}
sign = array.Length - flag;
for (int j3 = sign; j3 < array.Length; j3++)
{
array[j3] = s1[j3 - sign];

}
foreach (int o in array)
{
Console.Write(o);
}


}
}
}

[xiejunyema]

private static void MoveSubArrayToTheEnd(int[] array, int numberOfElements){
if (numberOfElements <= array.Length) {
for (int i = 0; i < array.Length; i++) {
if (i < numberOfElements) {
int temInt = array[0];
for (int j = 0; j < array.Length-1; j++) {
array[j] = array[j+1];
}
array[array.Length-1] = temInt;
}
}
}
}

[c_jiao_sdn]

最笨的做法
int[] a =new int[]{ 1, 2, 3, 4, 5, 6, 7 };
for (int i = 0; i < 7; i++)
{
Console.Write("{0} ", a[i]);
}
Console.WriteLine();
int sum ;
int m;
m = int.Parse(Console.ReadLine());
for (int i = 0; i < 7; i++)
{
sum=a[6];
for (int j = 6; j > 0;j-- )
{
a[j] = a[j - 1];
}
a[0] = sum;
if (a[6] == m)
break;
}
for (int i = 0; i < 7; i++)
{
Console.Write("{0} ", a[i]);
}
Console.WriteLine();
Console.ReadKey();

[darrenjj]

static void MoveSubArrayToTheEnd(int[] array, int numberOfElements)
{
int index =0;
int temp = array[index];
for (int i = 0; i < array.Length; i++)
{
index = index >= numberOfElements ? index - numberOfElements:array.Length - numberOfElements + index ;
temp += array[index];
array[index] = temp - array[index];
temp = temp - array[index];
}
}

[支持英文数字]

1. 在使用一o(1)空间复杂度的情况下，遍历数组
for (int i = 0; i < count; ++i){
int temp = array[0];
for (int j = 0; j < array.len; ++j){
array[j] = array[j+1];
}
array[len-1] = array[0];
}
这样的时间复杂度是o(n*m) n是数组的长度,m是中间的分界
2. 使用逆置的方法 函数reverse(int *a)完成的任务是将数组a逆置。
如a = {1 2 3 4}那么revers(a)={4 3 2 1}
因此如果前半段为m个，那么把前半段逆置，再把后半段逆置，然后整个数组逆置
如1 2 3 4 5 6 7
前半段逆置 3 2 1 4 5 6 7
后半段逆置 3 2 1 7 6 5 4
整个逆置 4 5 6 7 1 2 3
整个算法的时间复杂度为o(n).


[Quote=引用 14 楼 的回复:]
前半部倒置，后半部倒置，再整个倒置，代码回去在弄，上课中。。。
用的是BA=(A倒置B倒置)倒置
[/Quote]

[眔白]

[Quote=引用 322 楼 的回复:]
1. 在使用一o(1)空间复杂度的情况下，遍历数组
for (int i = 0; i < count; ++i){
int temp = array[0];
for (int j = 0; j < array.len; ++j){
array[j] = array[j+1];
}
array[len-1] = array[0];
}
这样的时间复杂度是o(n*……
[/Quote]

楼上的第一种方法没经过实践吧。。。
for (int i = 0; i < numberOfElements; ++i)
{
int temp = array[0];
for (int j = 0; j < array.Length-1; ++j)
{
array[j] = array[j + 1];
}
array[array.Length - 1] = temp;
}

[lf_dream520]

大家怎么只顾着写程序忘了面试官出题的意图呢？要实现这个很容易，关键是要看你的思维，大家怎么都没有想过，假如我输入的数字在数组里根本就不存在呢？等等 细节问题，要考虑清楚，面试官是要考你的编程习惯和思维。

[lf_dream520]

大家怎么只顾着写程序实现这个功能呢？怎么不明白面试官出题的意图呢？要实现这个功能很容易。关键是要考你编程的习惯与思维，大家都没有考虑输入的数字在数组中不存在的情况呀!等等细节要注意。思维要全面才是关键啊！

[litojoe]

int[] arr1 = new int[7];
            numberOfElements = numberOfElements % 7;
            if (numberOfElements == 0)
            {
                arr1 = arr;
            }
            else
            {                
                int m = numberOfElements;
                int n = 0;
                if (numberOfElements > 0)
                {
                    for (int i = 0; i < 7; i++)
                    {
                        if (m < 7)
                        {
                            arr1[i] = arr[m];
                            m++;
                        }
                        else
                        {
                            arr1[i] = arr[n];
                            n++;
                        }
                    }
                }
            }

            return arr1;