Ios Swift中栈的实现

我不熟悉Swift和iOS编程

我正在尝试测试一个简单的算法，需要一组堆栈。不必做任何花哨的事情（成堆的整数就可以了）

我从以下方面获得了堆栈实现：

计数和显示功能是我的贡献。但是当我试图声明堆栈数组时，我得到一个错误

var lines = IntStack()[5]

“IntStack”没有名为subscript的成员

我猜这与期权有关，但我能猜出它是什么

---

有什么帮助吗？

您在那里做的事情没有问题-这不是声明数组的语法。如果需要5个堆栈的数组，可以执行以下操作：

[IntStack(), IntStack(), IntStack(), IntStack(), IntStack()]

或者，您可以按如下方式初始化阵列：

Array(count: 5, repeatedValue: IntStack())

---

此外，您不需要将函数标记为

mutating

，除非它们实际改变了结构-因此

count（）

和

show（）

不需要它。

初始化堆栈时不需要声明堆栈的大小。只要叫这个就够了

var lines = IntStack()

---

还要注意，count（）和show（）方法不应该发生变异，因为它们不会以任何方式修改结构。

这里是一个使用Swift泛型的堆栈实现

struct Fruit {
let fruitName : String
let color : String
init(_ name: String,_ color: String) {
    self.fruitName = name
    self.color = color
}
}

let fruit1 = Fruit("Apple", "Red")
let fruit2 = Fruit("Grapes", "Green")

let fruitStack = Stack<Fruit>()
fruitStack.push(fruit1)
fruitStack.push(fruit2)

let fruitFfromStack = fruitStack.pop()
print("Fruit popped from Stack, Name : \(String(describing: fruitFfromStack?.fruitName)) ,Color : \(String(describing: fruitFfromStack?.color))")
let fruitFfromStack1 = fruitStack.pop()
print("Fruit popped from Stack, Name : \(String(describing: fruitFfromStack1?.fruitName)) ,Color : \(String(describing: fruitFfromStack1?.color))")

struct-Fruit{
让我们的名字：字符串
让颜色：字符串
初始化（u名称：字符串，uu颜色：字符串）{
self.fruitName=名称
self.color=颜色
}
}
让水果1=水果（“苹果”、“红色”）
让水果2=水果（“葡萄”、“绿色”）
设fruitStack=Stack（）
水果堆。推（水果1）
水果堆。推（水果2）
让fruitFfromStack=fruitStack.pop（）
打印（“从堆栈中弹出的水果，名称：\（字符串（描述：FROUTFROMSTACK？.FROUTCNAME）），颜色：\（字符串（描述：FROUTFROMSTACK？.Color）））
让fruitFfromStack1=fruitStack.pop（）
打印（“从堆栈中弹出的水果，名称：\（字符串（描述：FROUTFROMSTACK1？.FROUTCNAME）），颜色：\（字符串（描述：FROUTFROMSTACK1？.Color）））

完整代码如下：

详细信息

• Swift 5.1，Xcode 11.3.1

通用堆栈实现 可堆叠协议

堆叠

struct Stack:Stackable其中元素：equalable{
私有变量存储=[Element]（）
func peek（）->元素？{storage.last}
mutating func push（u元素：元素）{storage.append（元素）}
变异func pop（）->元素？{storage.popLast（）}
}
扩展堆栈：可均衡{
静态func==（lhs:Stack，rhs:Stack）->Bool{lhs.storage==rhs.storage}
}
扩展堆栈：CustomStringConvertible{
变量说明：字符串{“\（存储）”}
}
扩展堆栈：ExpressibleByArrayLiteral{
init（arrayliteralelements:Self.Element…{storage=elements}
}

用法

var stack=stack（）
堆栈推送（1）
堆栈推送（2）
堆栈推送（3）
打印（stack.peek（））
打印（stack.pop（））
打印（堆栈）
打印（stack==stack（））
堆栈=[3,2,1]
打印（堆栈）

只需查看此代码。具有泛型数据类型且不使用数组的堆栈示例

class Node<T>: CustomStringConvertible {

let value: T
var next: Node?

var description: String {
    guard let next = next else { return "\(value)" }
    return "\(value)\n" + String(describing: next)
}

init(value: T) {
    self.value = value
}
}


// Stack  class to hold all items
class Stack<T>: CustomStringConvertible {

var top: Node<T>?

var description: String {
    guard let top = top else { return "---- Stack is EMPTY ----" }
    return "---- Stack Begin ----\n" + String(describing: top) + "\n---- Stack End ----"
}

// push
func push(_ value: T) {
    let currentTop = top
    top = Node(value: value)
    top?.next = currentTop
}

@discardableResult
func pop() -> T? {
    let currentTop = top
    top = top?.next
    return currentTop?.value
}

@discardableResult
func peek() -> T? {
    return top?.value
}
}

类节点：CustomStringConvertible{
let值：T
下一步：节点？
变量说明：字符串{
guard let next=next else{return“\（value）”}
返回“\（值）\n”+字符串（描述：下一步）
}
初始值（值：T）{
自我价值=价值
}
}
//堆栈类以保存所有项
类堆栈：CustomStringConvertible{
var-top：节点？
变量说明：字符串{
guard let top=top-else{return'----堆栈为空--'}
返回“----堆栈开始----\n”+字符串（描述：top）+”\n----堆栈结束---”
}
//推
函数推送（u值：T）{
设currentTop=top
顶部=节点（值：值）
top？.next=当前top
}
@可丢弃结果
func pop（）->T{
设currentTop=top
top=top？下一个
返回currentTop？值
}
@可丢弃结果
func peek（）->T{
返回top？值
}
}

出色的实现！一个想法：我认为应该是：

func peek() -> Element? { storage.last }

---

可以只使用特定于堆栈的方法扩展数组。这可能是您想要的，也可能不是您想要的，这取决于您是否希望禁止类似数组的访问

协议栈{
关联类型元素
变异函数推送（项：元素）
//允许放弃结果而不生成警告。
@可丢弃结果
变异func pop（）->元素？
func peek（）->元素？
变量计数：Int{get}
}
扩展数组：堆栈{
变异函数推送（项：元素）{
self.append（项目）
}
变异func pop（）->元素{
如果let last=self.last{
self.remove（at:self.count-1）
最后返回
}
返回，无
}
func peek（）->元素{
自我终结
}
}

简单测试用例：

类StackTests:XCTestCase{
func testExample（）抛出{
var stack=Array（）
xctasertequal（stack.peek（），.none，“stack为空，peek返回none”）
xctasertequal（stack.pop（），.none，“stack为空，pop返回none”）
堆栈推送（项目：0）
堆栈推送（项目：1）
堆栈推送（项目：2）
xctasertequal（stack.peek（），2）
xctasertequal（stack.pop（），2）
xctasertequal（stack.peek（），1）
xctasertequal（stack.pop（），1）
xctasertequal（stack.peek（），0）
xctasertequal（stack.pop（），0）
}
}
[5]
显然是Swift所指的下标。我不是Swift专家，但通常“下标”需要一个数组或一个自定义对象，您已经向其中添加了类似索引器的数组。Try:var lines=IntStack（items:[5]）。我想你想用一个包含5的数组创建一个int堆栈。我不认为你需要
Repeat
这里，
array（count:5，repeatedValue:IntStack（））
也应该可以。哦，我不知道。谢谢谢谢大家！我使用了：Array（count:5，repeatedValue:IntStack（））并删除了count（）和show（）中的mutating（在编程时永远不要使用CMD+C CMD+V），它成功了！此数组实例化
struct Stack<Element>: Stackable where Element: Equatable {
    private var storage = [Element]()
    func peek() -> Element? { storage.last }
    mutating func push(_ element: Element) { storage.append(element)  }
    mutating func pop() -> Element? { storage.popLast() }
}

extension Stack: Equatable {
    static func == (lhs: Stack<Element>, rhs: Stack<Element>) -> Bool { lhs.storage == rhs.storage }
}

extension Stack: CustomStringConvertible {
    var description: String { "\(storage)" }
}
    
extension Stack: ExpressibleByArrayLiteral {
    init(arrayLiteral elements: Self.Element...) { storage = elements }
}

var stack = Stack<Int>()
stack.push(1)
stack.push(2)
stack.push(3)
print(stack.peek())
print(stack.pop())
print(stack)
print(stack == Stack<Int>())
stack = [3,2,1]
print(stack)

class Node<T>: CustomStringConvertible {

let value: T
var next: Node?

var description: String {
    guard let next = next else { return "\(value)" }
    return "\(value)\n" + String(describing: next)
}

init(value: T) {
    self.value = value
}
}


// Stack  class to hold all items
class Stack<T>: CustomStringConvertible {

var top: Node<T>?

var description: String {
    guard let top = top else { return "---- Stack is EMPTY ----" }
    return "---- Stack Begin ----\n" + String(describing: top) + "\n---- Stack End ----"
}

// push
func push(_ value: T) {
    let currentTop = top
    top = Node(value: value)
    top?.next = currentTop
}

@discardableResult
func pop() -> T? {
    let currentTop = top
    top = top?.next
    return currentTop?.value
}

@discardableResult
func peek() -> T? {
    return top?.value
}
}

func peek() -> Element? { storage.last }