Question

我有一个程序可以推送弹出和显示，但是我无法在我的程序中弹出推送的数字，可能我无法删除该数组的元素。到目前为止，这是我的代码：

import java.io.*;
import java.util.*;
import java.awt.*;
import javax.swing.*;

public class Class2 {
    public static void main(String args[]) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        System.out
                .print("1.)Push\n2.)Pop\n3.)Display\n4.)Exit\n\nChoose Item :");
        int x = Integer.parseInt(in.readLine());
        int[] a = new int[10];
        int b = 0;

        int i = 0;

        do
        {
            switch (x) {
            case 1:
                System.out.print("Enter Push number :");
                int v = Integer.parseInt(in.readLine());
                a[b] = v;
                b += 1;

                System.out.print("Item push :" + v + "\n");

                System.out
                        .print("1.)Push\n2.)Pop\n3.)Display\n4.)Exit\n\nChoose Item :");
                x = Integer.parseInt(in.readLine());

                if (x == 3) {
                    for (i = 0; i < b; i++) {
                        System.out.print(a[i] + " ");
                    }
                }
                break;

            case 2:

                System.out.print("Enter Pop Number :");
                int c = Integer.parseInt(in.readLine());

                if (c == a[i]) {

                }

                System.out.print("Item Pop :" + c + "\n");

                System.out
                        .print("1.)Push\n2.)Pop\n3.)Display\n4.)Exit\n\nChoose Item :");
                x = Integer.parseInt(in.readLine());

                if (x == 3) {
                    for (i = 0; i < b; i++) {
                        System.out.print(a[i] + " ");
                    }
                }

                break;
            case 4:
                break;
            }

        } while (x == 1 || x == 2);
    }
}

Answer 1

当您推送2，5和6时，您的队列中包含3个项目：

a[0] == 2
a[1] == 5
a[2] == 6

当您弹出2时，您想要从阵列中删除它。为此，您需要在弹出2之后将所有内容复制到上面的位置，以便最终得到：

a[0] == 5
a[1] == 6

这个代码看起来像是：

int popPosition = findPopPosition();
for(int i = popPosition + 1; i < MAX; i++)
    a[i - 1] = a[i];
b--; // Decrease effective queue size

findPopPosition()需要找到2所在的索引，因此在此示例中它将返回0。

或者，或者，用户可以直接输入弹出位置（因此弹出元素0），而不是指定他们想要弹出的值。这可能更有用。

Answer 2

您可以使用以下代码，它可能会解决您的问题。

            int brr[]= new int [a.length-1];
               int j=0;
               for(;j<a.length;j++)
               {
                   if(c== a[j])
                   {
                       break;
                   }
                   else{
                       brr[j]=a[j];
                   }
               }
               for(j=j+1;j<a.length;j++)
               {
                 brr[j-1] =a[j];
               }

在display show brr array中。

Answer 3

首先，如果要更改数组的元素，则不应使用数组。

如果你真的不想使用容器，那么你可以动态分配一个没有你要删除的元素的新数组（这可能是因为性能不佳和内存浪费而不是一个好主意）。

这可能是返回新数组的方法：

public static int[] removeElementAt(int [] array, int index){
    if(index > 0 && index < array.length){
        int [] newArray = new int[array.length - 1];
        for(int i=0; i<index; i++)
            newArray[i] = array[i]; // copying elements
        for(int i=index+1; i<array.length; i++)
            newArray[i-1] = array[i];
        array = newArray;
    }
    return array;
}

这只是一个简单的例子：

myArray = Class.removeElementAt(myArray, 5);  // removes 6. element

您还可以使用API ArrayUtils中的removeElement函数，如下所示：

array = ArrayUtils.removeElement(array, element)

另一个替代方法是将数组转换为列表，删除元素，然后将其转换回数组：不是一个好主意，因为您可以直接使用ArrayList。

因此，想要修改内容时使用动态容器，否则使用普通的原始数组。

Answer 4

并非所有测试用例都已处理，而是根据您的要求提供样本工作程序。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class ArrayDemo {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Enter the Array Max Capacity");
        int maxSize = Integer.parseInt(br.readLine().trim());
        int[] array = new int[maxSize];
        int arrayCount = 0;
        int choice = 0;
        do {
            System.out.println("\n1.Insert\n2.Delete\n3.Display\n4.Exit");
            choice = Integer.parseInt(br.readLine().trim());
            switch (choice) {
            case 1:
                boolean insertTrue = insertElement(br, maxSize, array,
                        arrayCount);
                if (insertTrue) {
                    arrayCount++;
                }
                break;
            case 2:
                System.out.println("Enter Element to delete");
                int delElement = Integer.parseInt(br.readLine().trim());
                int numOccurrence = getOccurrenceCount(array, arrayCount,
                        delElement);

                int newArrayCount = arrayCount - numOccurrence;
                if (numOccurrence == 0) {
                    System.out.println("No Such Element to delete");
                } else {
                    array = deleteElement(array, arrayCount, delElement,
                            newArrayCount,maxSize);

                }
                arrayCount =newArrayCount;
                break;
            case 3:
                displayArray(array, arrayCount);
                break;
            case 4:
                System.out.println("Exiting");
                break;
            default:
                System.out.println("Invalid Choice, Exiting");
                choice = 4;
            }
        } while (choice >= 1 && choice <= 3);
    }

    private static int[] deleteElement(int[] array, int arrayCount,
            int delElement, int newArrayCount,int maxSize) {
        int newArray[] = new int[newArrayCount];
        int index=0;
        for (int i = 0; i < arrayCount; i++) {
            if (array[i] != delElement) {
                newArray[index] = array[i];
                index++;
            }
        }
        resetArray(array, maxSize);
        for(int i=0;i<newArrayCount;i++){
            array[i]=newArray[i];
        }
        return array;
    }

    private static int[] resetArray(int[] array,int maxSize){
        for(int i=0;i<maxSize;i++){
            array[i]=0;
        }
        return array;
    }

    private static int getOccurrenceCount(int[] array, int arrayCount,
            int delElement) {
        int numOccurrence = 0;
        for (int i = 0; i < arrayCount; i++) {
            if (array[i] == delElement) {
                numOccurrence++;
            }
        }
        return numOccurrence;
    }

    private static void displayArray(int[] array, int arrayCount) {
        if (arrayCount == 0) {
            System.out.println("No Elements to Display");
        } else {
            System.out.println("Array is");
            for (int i = 0; i < arrayCount; i++) {
                System.out.print(array[i] + " ");
            }
            System.out.println("\n");
        }
    }

    private static boolean insertElement(BufferedReader br, int maxSize,
            int[] array, int arrayCount) throws IOException {
        if (arrayCount < maxSize) {
            System.out.println("Enter Element for Insertion");
            array[arrayCount] = Integer.parseInt(br.readLine().trim());
            return true;
        } else {
            System.out.println("Max Limit Reached, Insertion not possible");
            return false;
        }
    }
}

如何从原始数组中删除元素

4 个答案: