How to delete a chosen element in array?

Question

I have this assignment where I must delete a chosen element from an array, so I came up with this code:

strInput = Console.ReadLine();
for (int i = 0; i < intAmount; i++)
{
    if (strItems[i] == strInput)
    {
        strItems[i] = null;
        for (int x = 0; x < intAmount-i; x++)
        {
            i = i + 1;
            strItems[i - 1] = strItems[i];
        }
        intAmount = intAmount - 1;
    }
}

The problem is that, suppose I have an array [1,2,3,4,5,], and I want to delete 1. The output would be [2,3,4,5,5]. This also happens when I choose 2, but it does not happen when I choose any other number.

What am I doing wrong?

Answer 1

Can use Except method to filter the data

AllData = {10, 30, 20, 50}

FilterData = {30, 20}

Result = AllData.Except(​FilterData) 

Result will be {10, 50}

Answer 2

In your specific implementation i think u miss a break; statement, you should go out from the outer loop when you finish the inner loop. The assignment to null is not useful at all.

If the list is just a list of numbers why are you using strings? use integers directly if it is the case.

Your exercise seems to ask something like this, if you need to remove only one element.

public bool MyDelete(int[] array, int value) // Easy to do for strings too.
{
    bool found = false;
    for (int i = 0; i < array.Length; ++i)
    {
        if (found)
        {
            array[i - 1] = array[i];
        }
        else if (array[i] == value)
        {
            found = true;
        }
    }
    return found;
}

This function will returns true if it find the specified falue, false if not. It will move all items as you describe in your example, but of course, it will not change the size of the array.

Arrays are fixed size. You cannot change the size of an array, simply, the language don't allows that. Arrays are, were and will be always fixed size!

To remove an item from an array you should do something this:

public static T[] RemoveAt<T>(T[] array, int index) // hope there are not bugs, wrote by scratch.
{
    int count = array.Length - 1;
    T[] result = new T[count];

    if (index > 0)
        Array.Copy(array, 0, result, 0, index - 1);
    if (index < size)
        Array.Copy(array, index + 1, result, index, size - index);

    return result;
}

...
strItems = RemoveAt(strItems, index);

This function will create a new array that contains all elements except the one at the index you specify.

Now, why someone would do something like this instead of using a List or a Dictionary or wathever? Use directly a List without using an array.

Answer 3

I'm assuming you are working with a basic array of strings:

var strItems = new string[] { "1", "2", "3", "4", "5" };

In .NET, that array is always going to be 5 elements long. In order to remove an element, you are going to have to copy the remaining elements to a new array and return it. Setting the value at a position to null does not remove it from the array.

Now, with things like LINQ this is very easy (not shown here), or you could cheat using the List<> collection and do this:

var list = new List<string>(strItems);
list.Remove("3");
strItems = list.ToArray();

But I don't think that's going to teach you anything.

The first step is to find the index of the element you wish to remove. You can use Array.IndexOf to help you out. Let's find the middle element, "3":

int removeIndex = Array.IndexOf(strItems, "3");

If the element was not found, it will return a -1, so check for that before doing anything.

if (removeIndex >= 0)
{
     // continue...
}

Finally you have to copy the elements (except the one at the index we don't want) to a new array. So, altogether, you end up with something like this (commented for explanation):

string strInput = Console.ReadLine();
string[] strItems = new string[] { "1", "2", "3", "4", "5" };

int removeIndex = Array.IndexOf(strItems, strInput);

if (removeIndex >= 0)
{
    // declare and define a new array one element shorter than the old array
    string[] newStrItems = new string[strItems.Length - 1];

    // loop from 0 to the length of the new array, with i being the position
    // in the new array, and j being the position in the old array
    for (int i = 0, j = 0; i < newStrItems.Length; i++, j++)
    {
        // if the index equals the one we want to remove, bump
        // j up by one to "skip" the value in the original array
        if (i == removeIndex)
        {
            j++;
        }

        // assign the good element from the original array to the
        // new array at the appropriate position
        newStrItems[i] = strItems[j];
    }

    // overwrite the old array with the new one
    strItems = newStrItems;
}

And now strItems will be the new array, minus the value specified for removal.

Answer 4

• Arrays are a fixed sized, you can't shorten their length without creating a new array. All you can do is store the length of valid elements in the array (ie. after you remove 1 the length is 4).

  Also, I'm not sure if the order of elements in your array is important, but if it's not you could swap the first and last elements rather than moving every element after the one that's removed forward 1 position.

• An alternative to using an array is using a collection such as an ArrayList which will take care of resizing, removing and keeping a count of the amount of items in it, plus a lot more.

• However, since this is homework you might have to use arrays. Either keep track of the length with a variable, as opposed to using array.length, or create a new array each time you want to change the size. If you don't have to use arrays then look at the collections you can use in C#.

Answer 5

Arrays in C# are of a fixed size - once initialized you can only modify items, but you cannot add or remove items. If you want to delete an item from a collection you have two options:

1.) Create a new array that has all members of the original array minus the one you want to remove.

2.) Use a collection type that is resizable and allows to add or remove items like List<T> (List<int> in your case). This is what you would do in the "real world" if your collection is not static.