C# C语言中的弹出式数组#

我在C#中有一个字符串数组，我想从数组中弹出顶部元素（即删除第一个元素，并将所有其他元素向上移动一个）。在C#中有没有一种简单的方法可以做到这一点？我找不到数组.Pop方法

我需要使用ArrayList之类的东西吗？“我的数组”中项目的顺序很重要。

请使用或

List<String>
Queue<String>
Stack<String>

列表
队列
堆栈

来自MSDN：

using System;
using System.Collections.Generic;

namespace ConsoleApplication1
{
    class MSDNSample
    {
       static void Main()
       {
          string input = "a b c d";

          Stack<string> myStack = new Stack<string>(
             input.Split(new string[] { " " }, StringSplitOptions.None));

          // Remove the top element (will be d!)
          myStack.Pop();

          Queue<string> myQueue = new Queue<string>(

          input.Split(new string[] { " " }, StringSplitOptions.None));

          // Remove the first element (will be a!)
          myQueue.Dequeue();

       }
    }
}

使用系统；
使用System.Collections.Generic；
命名空间控制台应用程序1
{
类MSDNSample
{
静态void Main（）
{
字符串输入=“a b c d”；
Stack myStack=新堆栈(
Split（新字符串[]{“}，StringSplitOptions.None））；
//移除顶部元件（将为d！）
myStack.Pop（）；
队列myQueue=新队列(
Split（新字符串[]{“}，StringSplitOptions.None））；
//删除第一个元素（将是一个！）
myQueue.Dequeue（）；
}
}
}

（先进先出）或（后进先出）是您所追求的

---

NET中的数组是固定长度的-您不能从中删除元素，也不能向其中添加元素。您可以使用

列表

来实现这一点，但是

队列

和

堆栈

在需要队列/堆栈语义时更合适。

我遇到了上面提到的问题，但在队列的默认行为中遇到了问题，即在集合为空时引发异常（这不是真正的异常情况）。这是我对SafeQueue的实现，它将大多数操作推迟到基类，但实现了新的

Dequeue（）

和

Peek（）

操作，如果队列为空，则返回

default（T）

。如果可以将

default（T）

添加到队列中（不太可能用于对象类型，但很可能用于值类型），则无法通过

Peek

判断队列是否为空。一个新的

IsEmpty

属性可以告诉您何时完成

public class SafeQueue<T>: Queue<T>
{
    public SafeQueue() : base() { }

    public SafeQueue(int count) : base(count) { }

    public SafeQueue(IEnumerable<T> collection) : base(collection) { }

    public bool IsEmpty {get { return Count == 0; }}

    public new T Dequeue()
    {
        return IsEmpty ? default(T) : base.Dequeue();
    }

    public new T Peek()
    {
        return IsEmpty ? default(T) : base.Peek();
    }
}


[TestClass]
public class SafeQueueTests
{
    [TestMethod]
    public void SafeQueue_int_constructor_works()
    {
        var q = new SafeQueue<string>(5);
        Assert.IsNotNull(q);
        Assert.AreEqual(0, q.Count);
        q.Enqueue("a");
        Assert.AreEqual(1, q.Count);
        q.Enqueue("b");
        Assert.AreEqual(2, q.Count);
        q.Enqueue("c");
        Assert.AreEqual(3, q.Count);
        q.Enqueue("d");
        Assert.AreEqual(4, q.Count);
        q.Enqueue("e");
        Assert.AreEqual(5, q.Count);
        q.Enqueue("f");
        Assert.AreEqual(6, q.Count);
    }

    [TestMethod]
    public void SafeQueue_dequeue_works()
    {
        var q = new SafeQueue<string>();
        Assert.IsNotNull(q);
        Assert.AreEqual(0, q.Count);
        q.Enqueue("a");
        Assert.AreEqual(1, q.Count);
        q.Enqueue("b");
        Assert.AreEqual(2, q.Count);
        var result = q.Dequeue();
        Assert.AreEqual("a", result);
        result = q.Dequeue();
        Assert.AreEqual("b", result);
        result = q.Dequeue();
        Assert.AreEqual(null, result);
    }
    [TestMethod]
    public void SafeQueue_peek_works()
    {
        var q = new SafeQueue<string>();
        Assert.IsNotNull(q);
        Assert.AreEqual(0, q.Count);
        q.Enqueue("a");
        Assert.AreEqual(1, q.Count);
        var result = q.Peek();
        Assert.AreEqual("a", result);
        result = q.Dequeue();
        Assert.AreEqual("a", result);
        result = q.Dequeue();
        Assert.AreEqual(null, result);
    }

    [TestMethod]
    public void SafeQueue_isEmpty_works()
    {
        var q = new SafeQueue<string>();
        Assert.IsNotNull(q);
        Assert.AreEqual(0, q.Count);
        Assert.AreEqual(true, q.IsEmpty);
        q.Enqueue("content");
        Assert.AreEqual(false, q.IsEmpty);
        var result2 = q.Dequeue();
        Assert.AreEqual("content", result2);
        Assert.AreEqual(true, q.IsEmpty);
        result2 = q.Dequeue();
        Assert.AreEqual(true, q.IsEmpty);
        Assert.AreEqual(null, result2);
    }
    [TestMethod]
    public void SafeQueue_passedThroughQueueOperationContains_work()
    {
        var q = new SafeQueue<string>(5);
        Assert.IsNotNull(q);
        Assert.AreEqual(0, q.Count);
        q.Enqueue("a");
        Assert.AreEqual(1, q.Count);
        q.Enqueue("b");
        Assert.AreEqual(2, q.Count);
        q.Enqueue("c");
        Assert.AreEqual(3, q.Count);
        Assert.IsTrue(q.Contains("a"));
        Assert.IsFalse(q.Contains("asdfawe"));
        var outval = q.Dequeue();
        Assert.IsFalse(q.Contains("a"));
    }
    [TestMethod]
    public void SafeQueue_CantTellByDequeueIfQueueIsEmptyOrContainsNull()
    {
        var q = new SafeQueue<string>();
        Assert.IsNotNull(q);
        Assert.AreEqual(true, q.IsEmpty);
        q.Enqueue(null);
        Assert.AreEqual(false, q.IsEmpty);
        var result2 = q.Peek();
        Assert.AreEqual(null, result2);
        Assert.AreEqual(false, q.IsEmpty);
        result2 = q.Dequeue();
        Assert.AreEqual(true, q.IsEmpty);
        Assert.AreEqual(null, result2);
    }

}

公共类安全队列：队列
{
public SafeQueue（）：base（）{}
公共安全队列（整数计数）：基本（计数）{
公共安全队列（IEnumerable集合）：基（集合）{}
public bool IsEmpty{get{return Count==0；}}
公共新T退出队列（）
{
return IsEmpty？默认值（T）：base.Dequeue（）；
}
公共新T Peek（）
{
return IsEmpty？默认值（T）：base.Peek（）；
}
}
[测试类]
公共类安全队列测试
{
[测试方法]
公共空间安全队列(内部)建造商(工程)
{
var q=新的安全队列（5）；
Assert.IsNotNull（q）；
断言.AreEqual（0，q.Count）；
q、 排队（“a”）；
断言.AreEqual（1，q.Count）；
q、 排队；
断言.AreEqual（2，q.Count）；
q、 排队；
断言为相等（3，q.Count）；
q、 排队；
断言为相等（4，q.Count）；
q、 排队；
断言.AreEqual（5，q.Count）；
q、 排队；
断言.AreEqual（6，q.Count）；
}
[测试方法]
公共空间安全排队(出队)工程()
{
var q=新的安全队列（）；
Assert.IsNotNull（q）；
断言.AreEqual（0，q.Count）；
q、 排队（“a”）；
断言.AreEqual（1，q.Count）；
q、 排队；
断言.AreEqual（2，q.Count）；
var result=q.Dequeue（）；
断言。等于（“a”，结果）；
结果=q.Dequeue（）；
断言。等于（“b”，结果）；
结果=q.Dequeue（）；
aresequal（null，result）；
}
[测试方法]
公共空间安全队列_peek_works（）
{
var q=新的安全队列（）；
Assert.IsNotNull（q）；
断言.AreEqual（0，q.Count）；
q、 排队（“a”）；
断言.AreEqual（1，q.Count）；
var result=q.Peek（）；
断言。等于（“a”，结果）；
结果=q.Dequeue（）；
断言。等于（“a”，结果）；
结果=q.Dequeue（）；
aresequal（null，result）；
}
[测试方法]
公共空间安全队列(i空)工程()
{
var q=新的安全队列（）；
Assert.IsNotNull（q）；
断言.AreEqual（0，q.Count）；
断言.AreEqual（真，q.IsEmpty）；
q、 排队（“内容”）；
断言.AreEqual（false，q.IsEmpty）；
var result2=q.Dequeue（）；
Assert.AreEqual（“内容”，结果2）；
断言.AreEqual（真，q.IsEmpty）；
result2=q.Dequeue（）；
断言.AreEqual（真，q.IsEmpty）；
aresequal（null，result2）；
}
[测试方法]
public void SafeQueue\通过QueueOperationContains\工作（）传递
{
var q=新的安全队列（5）；
Assert.IsNotNull（q）；
断言.AreEqual（0，q.Count）；
q、 排队（“a”）；
断言.AreEqual（1，q.Count）；
q、 排队；
断言.AreEqual（2，q.Count）；
q、 排队；
断言为相等（3，q.Count）；
Assert.IsTrue（q.Contains（“a”））；
Assert.IsFalse（q.Contains（“asdfawe”）；
var outval=q.Dequeue（）；
Assert.IsFalse（q.Contains（“a”））；
}
[测试方法]
public void SafeQueue_canttelbydequeueifqueueismptyorcontainsnall（）
{
var q=新的安全队列（）；
Assert.IsNotNull（q）；
断言.AreEqual（真，q.IsEmpty）；
q、 排队（空）；
断言.AreEqual（false，q.IsEmpty）；
var result2=q.Peek（）；
aresequal（null，result2）；
断言.AreEqual（false，q.IsEmpty）；
result2=q.Dequeue（）；
断言.AreEqual（真，q.IsEmpty）；
aresequal（null，result2）；
}
}

这在阵列中是完全可能的，但效率不高。实际上，您必须使用循环向下移动数组，并在for循环中设置arr[i]=arr[i+1]。在此之后，如果需要，必须调整数组的大小

由于这些警告，数组并不是处理这个问题的最佳数据结构。数组最适合于静态数据或大小不变的数据

由于要删除数据，

string[] array = ...;
array = array.Skip(1).ToArray();

  public static class ArrayExtensions
    {
        /// <summary>
        /// Removes the last element.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="array">The array.</param>
        /// <returns>T[].</returns>
        public static T[] RemoveLastElement<T>(this T[] array)
        {
            var stack = new Stack<T>(array);
            stack.Pop();
            return stack.ToArray().Reverse().ToArray();
        }

        /// <summary>
        /// Removes the first element.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="array">The array.</param>
        /// <returns>T[].</returns>
        public static T[] RemoveFirstElement<T>(this T[] array)
        {
            var queue = new Queue<T>(array);
            queue.Dequeue();
            return queue.ToArray();
        }
    }

  [Test]
        public void ExtensionsTests_ArrayExtensionTests()
        {
            var data = new[] { 'A', 'B', 'C', 'D' };

            Assert.AreEqual("BCD", string.Join("", data.RemoveFirstElement()));
            Assert.AreEqual("ABC", string.Join("", data.RemoveLastElement()));
        }

var args = { "value1", "value2" };
var queue = new Queue<string>(args);
var arg1 = queue.Dequeue();
var arg2 = queue.Dequeue();

    /// <summary>
    /// Pop value from top of string[] array
    /// </summary>
    public void PopStringArray(ref string[] array)
    {
        int newLength = array.Length;
        string[] temp = new string[array.Length];

        for (int i = array.Length - 1; i >= 1; i--)
            temp[i - 1] = array[i];

        array = temp;
    }

    public static T Pop<T>(this IList<T> collection) where T : class
    {
        if (collection == null || !collection.Any())
        {
            throw new ArgumentException($"Failed to pop list of {typeof(T)}, cannot be empty or null");
        }

        var lastItemAsJson = JsonSerializer.Serialize(collection.Last());
        collection.Remove(collection.Last());
        return JsonSerializer.Deserialize<T>(lastItemAsJson);
    }