Question

我坚持“排序”2个不同的阵列。我的目标是摆脱array1和array2中包含的数字。

以下是一个例子：

int [] arr1 = {1,2,3,4,5,6 } ;
int [] arr2 = {3,4} ;

数组arr1中的值应如下所示：1,2,5,6（不含3和4）

到目前为止我的代码：

static int[] test(int[]a,int[]b)
    {
        int i = 0;
        int g = 0;
        int d = 0;

        int indexB = 0;

        while( i < a.Length)
        {

            bool dvojnost = false;

            int j = 0;
            while (j<b.Length)
            {
                if (a[i] == b[j])
                {
                    dvojnost = true;
                    indexB = j;
                    break;
                }
                else
                j++;
            }

                    int trenutniElementB = 0;
                if(dvojnost==true)
                {
                    while (trenutniElementB < b.Length)
                    {
                        if (trenutniElementB != indexB)
                        {
                            b[g] = b[trenutniElementB];
                            g++;
                            trenutniElementB++;
                        }
                        else
                        {
                            trenutniElementB++;
                        }
                    }
                }




            int h = 0;
            if (dvojnost == true)
            {
                while (h < a.Length)
                {
                    if (h != i)
                    {
                        a[d] = a[h];
                        d++;
                        h++;
                    }
                    else
                    {
                        h++;
                    }
                }
            }


            i++;
        }
        return a;

    }

此编码仅用于扩展我对数组的知识：）

Answer 1

使用LINQ： - ）

int[] result = array1.Except(array2).ToArray();

Answer 2

如果你决定只使用循环而没有Linq或Lists，你可以选择这个......

static void Main(string[] args)
{
    int[] arr1 = { 1, 2, 3, 4, 5, 6 };
    int[] arr2 = { 3, 4 };
    int[] result = test(arr1, arr2);
}

static int[] test(int[] a, int[] b)
{
    int k = 0;
    bool toAdd;
    int[] output = new int[] { };

    for (int i = 0; i < a.Length; i++)
    {
        toAdd = true;

        for (int j = 0; j < b.Length; j++)
        {
            if (a[i] == b[j])
            {
                toAdd = false;
                break;
            }
        }
        if (toAdd)
        {
            Array.Resize(ref output, k + 1);
            output[k] = a[i];
            k++;
        }             
    }
    return output;
}

Answer 3

如果您将第二个数组视为结果的排除列表，则可以使用通用List＆lt;＆gt; class足以创建这样的简单代码：

    static int[] test(int[] a, int[] b)
    {
        List<int> result = new List<int>();
        List<int> exclusion = new List<int>(b);
        for (int i = 0; i < a.Length; i++)
        {
            if (exclusion.IndexOf(a[i]) >= 0)
                continue;
            result.Add(a[i]);
        }
        return result.ToArray();
    }

Answer 4

将您的方法分为两部分。首先摆脱重复，然后对数组进行排序：

public int[] RemoveAndSort(int[] a, int[] b){
  List<int> temp = new List<int>();
  for(int i = 0; i < a.Length; i++){
    bool found = false;
    for(int j = 0; j < b.Length; j++){
      if(a[i] == b[j]){
        found = true;
      }
    }
    if(!found) temp.Add(a[i]);
  }
  temp.Sort();
  return temp.ToArray();
}

我在我的解决方案中使用了List，但您也可以在方法开头使用一个与a长度相同的新空数组。

Answer 5

你可以尝试这个，没有任何泛型集合:)只有数组：

public class Program
{
    static void Main(string[] args)
    {
        int resultLength = 0;
        int[] arr1 = { 1, 2, 3, 4, 5, 6 };
        int[] arr2 = { 3, 4 };
        int[] result = new int[resultLength];

        for(int i = 0; i < arr1.Length; i++)
        {
            if(!arr2.Exists(arr1[i]))
            {
                resultLength++;
                Array.Resize(ref result, resultLength);
                result[resultLength- 1] = arr1[i];
            }
        }            
    }
}

public static class MyExtensions
{
    public static bool Exists(this int[] array, int value)
    {
        for(int i = 0; i < array.Length; i++)
        {
            if (array[i] == value)
                return true;
        }
        return false;
    }
}

Answer 6

不要重新发明轮子，使用LINQ。无论如何，如果你这样做是为了理解数组的一个练习，这里有一个避免LINQ altoghether的命令：

public static T[] Except<T>(this T[] first, T[] second)
{
    if (first == null)
        throw new ArgumentNullException(nameof(first));

    if (second == null)
        throw new ArgumentNullException(nameof(second));

    if (second.Length == 0)
        return first;

    var counter = 0;
    var newArray = new T[first.Length];

    foreach (var f in first)
    {
        var found = false;

        foreach (var s in second)
        {
            if (f.Equals(s))
            {
                found = true;
                break;
            }
        }

        if (!found)
        {
            newArray[counter] = f;
            counter++;
        }
    }

    Array.Resize(ref newArray, counter);
    return newArray;
}

如何在2个数组之间跳过相同的值

6 个答案: