删除int数组中重复项的程序

Question

我写了一些代码来从 Integer 数组中删除重复项。 我不想使用任何内置关键字/属性。

这是我的逻辑：

int[] iArray = {1,2,3,2,3,4,3};              
int t = 0;
int arraysize = iArray.Length;
for (int m = 0; m < arraysize; m++)
{
    if (iArray[m] != iArray[t])
    {
        t++;
        iArray[t] = iArray[m];
    }
}
arraysize = t + 1;
for (int m = 0; m < arraysize; m++)
{
    Console.WriteLine(iArray[m]);
}

Output 应该是：

1,2,3,4

它没有给出所需的 output。伙计们，这不是家庭作业。 这是自学。 没有LINQ，请包含关键字。 谢谢你的回复。

谢谢。

Answer 1

由于这是一个家庭作业，我不会修复你的代码，而是给你一些笔记：

1. 您将无法使用单个循环并且没有内置函数; 你需要两个嵌套循环
2. 找到重复值时，将数组项向前移动1，并减小数组“活动区域”的大小; 你需要另一个嵌套循环来完成移动。

Answer 2

这是使用两个嵌套的foreach循环来实现它的方法：

var array = new int[] {1,2,3,2,3,4,3};  

var result = new List<int>();
foreach(var item in array)
{
    bool found = false;
    foreach(var resultItem in result)
    {
        if(resultItem == item) found = true;
    }

    if(!found)
    {
        result.Add(item);
    }
}

如果您不想使用List<int> ，则需要创建一个具有第一个数组大小的临时数组。 然后，当处理完毕后，您需要跟踪您真正找到的项目数量并将其复制到新阵列中。

Answer 3

问题是您只是将每个元素与前一个元素进行比较。 由于这是一项自学练习，我只是概述一下如何做，并让你弄清楚细节。

您需要两个嵌套循环：

• 第一个循环遍历每个元素。
• 第二个循环将当前元素与您到目前为止看到的所有其他元素进行比较。

请注意，这需要O（n ² ）时间。

---

您可以使用其他方法更快地完成此操作：

• 首先对输入进行排序：O（n log（n））时间
• 使用HashSet或Enumerable.Distinct ：O（n）时间。

但是这些后一种方法可能都不被您不使用内置类/方法的要求所禁止。

Answer 4

算法的一种非常基本的形式，可以实现您想要的：

        int[] iArray = {1,2,3,2,3,4,3};
        int[] newArray = new int[iArray.Length];          

        //initialize array with a marker
        for(int i = 0; i < newArray.length; i++){
          newArray = -1 //this shouldn't be a potential value in the original arr
        }

        bool contains = false;
        int curLength = 0;
        for (int m = 0; m < iArrayLength; m++)
        {
           contains = false;
           for(int k = 0; k < curLength; k++){
                 if(newArray[k] == iArray[m]){
                    contains = true;
                    break;
                 }
           }
           if(!contains) 
                 newArray[curLength++] = iArray[m];
        }
        for (int m = 0; m < curLength; m++)
        {
            Console.WriteLine(newArray[m]);
        }

Answer 5

好吧，你说你不想要任何内置的东西，所以让我们从头开始做所有事情。

有两种方法（我知道）可以做到这一点。 一个具有复杂度O（n ^ 2），一个具有复杂度O（n + n * log（n））。 第二个更快，但第一个更容易。

更慢（但更容易）的解决方案：O（n ^ 2）

int[] iArray = {1,2,3,2,3,4,3};
List<int> unique = new List<int>(iArray.Length);

for(int i = 0; i<iArray.length; i++)
{
    bool found = false;
    for(int prev=0; prev<i; prev++)
    {
        if(iArray[prev] == iArray[i])
        {
            found = true;
            break;
        }
    }

    if(!found)
    {
        unique.Add(iArray[i]);
    }
}

iArray = unique.ToArray();

for(int i=0; i<iArray.Length; i++)
{
    Console.WriteLine(iArray[i]);
}

更快（但更复杂）的解决方案：O（n + n * log（n））

int[] iArray = {1,2,3,2,3,4,3};
List<int> unique = new List<int>(iArray.Length);

// Sort the array here. Use your favorite algorithm. Sorting is so widely
// covered elsewhere that I will avoid typing it here. Complexity should 
// be O(n*log(n))

if( iArray.Length > 0)
{
    unique.Add(iArray[0]);
}

for(int i=1; i<iArray.length; i++)
{
    if(iArray[i] != iArray[i-1])
    {
        unique.Add(iArray[i]);
    }
}

iArray = unique.ToArray();

for(int i=0; i<iArray.Length; i++)
{
    Console.WriteLine(iArray[i]);
}

Answer 6

只需填写字典并使用Keys作为结果数组。

Dictionary<int, int> dict = new Dictionary<int, int>();
for(int i = 0; i < array.Length; i++) {
  dict[array[i]] = 0;
}

dict.Keys - 结果。

Answer 7

这是解决方案：

int[] iArray = { 1, 2, 3, 2, 3, 4, 3 };
int[] EachWords = { 1, 2, 3, 2, 3, 4, 3 };

for (int p = 0; p < EachWords.Length; p++)
{
    for (int j = 0; j < EachWords.Length; j++)
    {
        if (EachWords[p] == EachWords[j] && p != j)
        {
            List<int> tmp = new List<int>(EachWords);
            tmp.RemoveAt(j);
            EachWords = tmp.ToArray();
        }
    }
}

for (int j = 0; j < EachWords.Length; j++)
{
    Response.Write(EachWords[j].ToString() + "\n");
}

现在，它将显示1, 2, 3, 4

Answer 8

如果您先订购商品，并且在与下一个商品进行比较后，您将获得nlogn费用。

算法：

1. 订单数组

2. foreach elem if（has_next && next is equal）remove element; 下一个

3. 打印阵列

如果空间成本不是问题，你可以使用辅助哈希表结构。 但我一直认为我的想法更简单。

Answer 9

您还可以使用比arrayList更快的Dictionary

    public Dictionary<string,int> removeDupUsingDictionary(int[] n)
    {

        Dictionary<string,int> numbers = new Dictionary<string,int>();

        for( int i = 0 ; i< n.Length; i ++)
        {
            try
            {
                numbers.Add("value" + n[i], n[i]);
            }
            catch (Exception e)
            {
                Console.WriteLine("Already the value" + n[i] + "present in the dictionary");
            }


        }

        return numbers;

    }



    static void Main(string[] args)
    {

        Program num = new Program();
        int[] n = { 6,5,1, 2, 3, 4, 5, 5, 6,6,6,6,6,6 };

        Dictionary<string, int> dictionary = new Dictionary<string, int>();

        int size = n.Length;


        ArrayList actual = num.removeDup(n);

        num.removeDupUsingDictionary(n);



    }

Answer 10

static void Main(string[] args)
        {
            int[] array = new int[] { 4, 8, 4, 1, 1, 4, 8 };            
            int numDups = 0, prevIndex = 0;

            for (int i = 0; i < array.Length; i++)
            {
                bool foundDup = false;
                for (int j = 0; j < i; j++)
                {
                    if (array[i] == array[j])
                    {
                        foundDup = true;
                        numDups++; // Increment means Count for Duplicate found in array.
                        break;
                    }                    
                }

                if (foundDup == false)
                {
                    array[prevIndex] = array[i];
                    prevIndex++;
                }
            }

            // Just Duplicate records replce by zero.
            for (int k = 1; k <= numDups; k++)
            {               
                array[array.Length - k] = '\0';             
            }


            Console.WriteLine("Console program for Remove duplicates from array.");
            Console.Read();
        }

Answer 11

int[] iArray = { 1, 2, 3, 2, 3, 4, 3 };

        List<int> unique = new List<int>(iArray.Length);                      

        for (int i = 0; i < iArray.Length; i++)
        {
            int count=0;
            for (int j = i + 1; j < iArray.Length; j++)
            {
                if (iArray[i] == iArray[j])
                {
                    count++;
                }
            }
            if (count==0)
            {
                unique.Add(iArray[i]);
            }
        }

        iArray = unique.ToArray();

        for (int i = 0; i < iArray.Length; i++)
        {
            Console.WriteLine(iArray[i]);
        }

Answer 12

您可以使用.Distinct（）扩展方法，如下所示，

int[] oldArray = { 1, 2, 3, 3, 4};
    int[] newArray  = oldArray .Distinct().ToArray();

Answer 13

你的ans是：

    int[] oldArray = {1, 2, 3, 2, 3, 4, 3 };
    int[] newArray = oldArray.Distinct().ToArray();

    String ans = "";
    for (int m = 0; m < newArray.Length; m++)
    {
        ans += newArray[m] +",";
    }
    Console.WriteLine(ans);

Answer 14

此代码在 Python 中。

array1 = [1,2,2,3,3,3,4,5,6,4,4,5,5,5,5,10,10,8,7,7,9,10]

array1.sort() # sorting is must
print(array1)

current = NONE
count = 0 

# overwriting the numbers at the frontal part of the array
for item in array1:
    if item != current:
        array1[count] = item
        count +=1
        current=item
        
       

print(array1)#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 5, 5, 5, 5, 6, 7, 7, 8, 9, 10, 10, 10]

print(array1[:count])#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

最有效的方法是：

array1 = [1,2,2,3,3,3,4,5,6,4,4,5,5,5,5,10,10,8,7,7,9,10]

array1.sort()
print(array1)

print([*dict.fromkeys(array1)])#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

#OR#
aa = list(dict.fromkeys(array1))
print( aa)#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Answer 15

这个解决方案是在javascript中。

var myval = [1, 2,3, 4, 4, 5, 5, 6, 7];

var tempVal = [];
var l = myval.length;
for(var i=0; i<l; i++){
    if(tempVal.length === 0){
        tempVal.push(myval[i]);
    }
    else{
        var tempL = tempVal.length;
        var foundCount = 0;
        var lookedFor = myval[i];
        for(var t = 0; t<tempL; t++){
            if(tempVal[t] === lookedFor){
                foundCount++;
            }

        }
        if(foundCount === 0){
            tempVal.push(lookedFor);
        }
    }
}