数组元素的移动(删除) C#实现

下面有四个问题:

1. 把数组元素前后部分交换 MoveFirstPartOfArrayToTheEnd(int[] array, int index) 比如 {1,2,3,4,5,6,7} 3  => {4,5,6,7,1,2,3}
2. 把数组元素前后部分交换 MoveFirstPartOfArrayToTheEnd(int[]  array, int value）比如 {1,2,8,4,5,6,7} 8  => {4,5,6,7,1,2,8}
3. 把数组一段移动到后面MoveSomeElementsToTheEnd(int[]  array, int startIndex, int length)比如{1,2,3,4,5,6,7,8}  3  3  => {1,2,3,7,8,4,5,6}
4. 把数组中重复的元素变成0放到最后面RemoveDulplicatedElements(int[] array) 比如 {1,3,3,2,4,4,4,5} => {1,3,2,4,5,0,0,0}

你首先想到的办法是什么？

1. 申请一个临时数组把FistPart和EndPart交换
2. 同上，只要找到对应值的下标即可。
3. 同上申请临时数组，把要移动的段放到临时数组里
4. 申请一个临时的List<int>把唯一的元素加到List里面，再重新赋给Array。

     class Program
     {
         static void Main(string[] args)
         {
             //
             int[] array1 = { , , , , , ,  };
             MoveFirstPartOfArrayToTheEnd(array1, );
             printArray(array1);

             //
             int[] array2 = { , , , , , ,  };
             MoveFirstPartOfArrayToTheEndValue(array2, );
             printArray(array2);

             //
             int[] array3 = { , , , , , , ,  };
             MoveSomeElementsToTheEnd(array3, , );
             printArray(array3);

             //
             int[] array4 = { , , , , , , ,  };
             removeDulplicatedElements(array4);
             printArray(array4);

         }

         private static void printArray(int[] array)
         {
             for (int i = ; i < array.Length; i++)
             {
                 Console.Write(array[i]);
             }
             Console.WriteLine();
         }

         public static void MoveFirstPartOfArrayToTheEnd(int[] array, int index)
         {
             if (index >= array.Length || index <= )
             {
                 throw new Exception("index must be greater than 0 and less than " + array.Length);
             }

             //Move the first part of array to a temp array
             int[] temp = new int[index];
             for (int i = ; i < index; i++)
             {
                 temp[i] = array[i];
             }

             //Move forward the other element
             for (int i = ; i < array.Length - index; i++)
             {
                 array[i] = array[i + index];
             }

             //Move the first part back to the end of array
             int j = ;
             for (int i = array.Length - index; i < array.Length; i++)
             {
                 array[i] = temp[j];
                 j++;
             }
         }

         public static void MoveFirstPartOfArrayToTheEndValue(int[] array, int value)
         {
             bool move = false;

             //Search the value in the array
             for (int i = ; i < array.Length; i++)
             {
                 if (array[i] == value)
                 {

                     //Move the first part if we find the value
                     MoveFirstPartOfArrayToTheEnd(array, i + );
                     move = true;
                     break;
                 }
             }

             if (!move)
             {
                 throw new Exception("No matched value is found in the array");
             }
         }

         public static void MoveSomeElementsToTheEnd(int[] array, int startIndex, int length)
         {
             if (startIndex <  || startIndex >= array.Length - )
             {
                 throw new Exception("startIndex must be greater than 0 and less than " + (array.Length - ).ToString());
             }

             if (startIndex + length +  > array.Length)
             {
                 throw new Exception("Please provide a valid length");
             }

             int[] temp = new int[length];
             for (int i = ; i < temp.Length; i++)
             {
                 temp[i] = array[startIndex + i];
             }

             //Move forward the other element
             for (int i = startIndex; i < array.Length - length; i++)
             {
                 array[i] = array[i + length];
             }

             //Move the first part back to the end of array
             int k = ;
             for (int i = array.Length - length; i < array.Length; i++)
             {
                 array[i] = temp[k];
                 k++;
             }
         }

         public static void removeDulplicatedElements(int[] array)
         {
             List<int> temp = new List<int>();
             for (int i = ; i < array.Length; i++)
             {
                 if (array[i] == )
                     continue;
                 temp.Add(array[i]);
                 for (int j = i + ; j < array.Length; j++)
                 {
                     if (array[i] == array[j])
                     {
                         array[j] = ;
                     }
                 }
             }

             for (int i = ; i < array.Length; i++)
             {
                 if (i < temp.Count)
                 {
                     array[i] = temp[i];
                 }
                 else
                 {
                     array[i] = ;
                 }
             }
         }
     }

现在要求优化算法，空间复杂度为O（1），该如何去优化呢？

1. 我们先看{1，2，3，4，5，6，7}3如何变成{4，5，6，7，1，2，3}的，首先前后部分各自反转变成{3，2，1，7，6，5，4}然后再把整个数组反转就变成了{4，5，6，7，1，2，3}。
2. 同上，只要找到对应值的下标即可。
3. 我们再看{1,2,3,4,5,6,7,8}  3  3  => {1,2,3,7,8,4,5,6}过程，前面不动的部分{1,2,3}先不管，且看后面{4,5,6,7,8}=>{7,8,4,5,6},同上面，各自反转尔后整体反转{6，5，4，8，7}=>{7,8,4,5,6}
4. {1,3,3,2,4,4,4,5} => {1,3,2,4,5,0,0,0}的过程，先把重复的元素变成0，再依次移动到最后，{1,3,3,2,4,4,4,5} => {1,3,0,2,4,0,0,5}=>{1,3,2,4,0,0,5,0}=>{1,3,2,4,0,5,0,0}=>{1,3,2,4,5,0,0,0}

从上面可以看出都用到了一个通用的方法就是反转数组ReversArray().这个操作只需要申请一个临时变量。即空间复杂度为O(1)

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;

 namespace TransposeArray
 {
     class Program
     {
         static void Main(string[] args)
         {
             //1 {1,2,3,4,5,6,7} 3  => {4,5,6,7,1,2,3}
             int[] Array1 = new int[] { , , , , , ,  };
             TransposeByIndex(Array1, );
             PrintArray(Array1);
             //2 {1,2,8,4,5,6,7} 8  => {4,5,6,7,1,2,8}
             int[] Array2 = new int[] { , , , , , ,  };
             TransposeByValue(Array2, );
             PrintArray(Array2);
             //3 {1,2,3,4,5,6,7,8}  3  3  => {1,2,3,7,8,4,5,6}
             int[] Array3 = new int[] { , , , , , , ,  };
             TransposeBySegment(Array3, , );
             PrintArray(Array3);
             //4  {1,3,3,2,4,4,4,5} => {1,3,2,4,5,0,0,0}
             int[] Array4 = new int[] { , , , , , , ,  };
             RemoveDuplicated(Array4);
             PrintArray(Array4);
         }

         //Print the array.
         public static void PrintArray(int[] array)
         {
             for (int i = ; i < array.Length; i++)
             {
                 Console.Write(array[i] + ", ");

             }
             Console.ReadLine();
         }

         // Reverse an Array
         public static void ReverseArray(int[] array, int left, int right)
         {

             for (; left < right; ++left, --right)
             {
                 int tmp = array[left];
                 array[left] = array[right];
                 array[right] = tmp;
             }
         }

         // Reverse thrice respectively.
         public static void TransposeByIndex(int[] array, int index)
         {
             ReverseArray(array, , index);
             ReverseArray(array, index + , array.Length - );
             ReverseArray(array, , array.Length - );
         }

         //Transpose by value
         public static void TransposeByValue(int[] array, int value)
         {
             for (int i = ; i < array.Length; i++)
                 if (array[i] == value)
                 {
                     TransposeByIndex(array, i);
                 }
         }

         //Tanspose by segment
         public static void TransposeBySegment(int[] array, int StartIndex, int Length)
         {
             int div = StartIndex + Length - ;
             int end = array.Length - ;
             ReverseArray(array, StartIndex, div);
             ReverseArray(array, div + , end);
             ReverseArray(array, StartIndex, end);
         }

         //Romove duplicated Elements
         public static void RemoveDuplicated(int[] array)
         {
             for (int i = array.Length - ; i > ; i--)
             {
                 for (int j = ; j < i; j++)
                 {
                     if (array[i] == array[j])
                     {
                         array[i] = ;
                     }
                 }

             }

             for (int i = ; i < array.Length - ; i++)
             {
                 for (int j = array.Length - ; j > i; j--)
                 {
                     if (array[i] ==  && array[j] != )
                     {
                         ReverseArray(array, i, j);
                         ReverseArray(array, i, j - );
                     }
                 }
             }

         }
     }
 }

第4个问题可以用其他方法实现，不去调用ReversArray方法。

找到重复元素置为0，然后搜索为0的值，再把后面的元素前移，最后一个元素置0。空间复杂度也为O（1）