使用栈反转字符串的 Swift 程序

---

栈是一种基于 LIFO（后进先出）原则的数据结构。它用于存储和管理数据，其中最近添加的项目是第一个从栈中移除的项目。栈支持以下操作：

• 入栈 - 用于将元素添加到栈中。因此，在 Swift 中，我们通过 append() 方法实现入栈操作。

语法

func push(_ items: T) {
   item.append(items)
}

在这里，append() 函数将一个新元素压入 item 栈中。

• 出栈 - 用于从栈中移除元素。因此，在 Swift 中，我们通过 popLast() 方法实现出栈操作。

语法

func pop() -> T? {
   return item.popLast()
}

在这里，popLast() 函数从栈中移除最近添加的元素。

• isEmpty - 用于检查栈是否为空。因此，在 Swift 中，我们使用 isEmpty 属性来实现此操作。

语法

 func isEmpty() -> Bool {
   return item.isEmpty
}

在这里，isEmpty 属性用于在栈为空时返回 true。否则，如果栈不为空，则返回 false。

在 Swift 中，要反转字符串，我们将使用基于数组和基于结构的栈实现。这是实现栈最常见和最直接的方法。

示例

Input: String = "Ram got first place"

Output: "ecalp tsrif tog maR"

在这里，我们使用栈反转输入字符串。

算法

• 步骤 1 - 创建一个接收输入字符串的函数。

• 步骤 2 - 现在此函数首先使用数组创建一个栈。

• 步骤 3 - 将原始字符串中的所有字符压入栈中。

• 步骤 4 - 创建一个空字符串来存储结果。

• 步骤 5 - 现在开始从栈中弹出最近添加的字符，直到栈为空，并将它们存储到一个新字符串中。

• 步骤 6 - 返回反转后的字符串。

• 步骤 7 - 创建一个字符串。

• 步骤 8 - 调用函数并将输入字符串作为参数传递给它。

• 步骤 9 - 显示输出。

示例 1

在以下 Swift 程序中，我们将使用栈保留一个字符串。为此，我们创建了一个接收输入字符串的函数。然后它使用数组实现创建了一个栈。然后它使用 append() 方法将给定字符串的所有字符压入栈中。

然后它创建一个空字符串来存储反转后的字符串。然后它使用 popLast() 函数从栈中弹出字符，同时栈不为空，并将它们附加到新的空字符串中。最后，此函数使用栈返回反转后的字符串。

import Foundation
import Glibc

func reverseStringUsingStack(str: String) -> String {
   var myStack = [Character]()
    
   for char in str {
      myStack.append(char)
   }
    
   var reversedStr = ""
    
   while !myStack.isEmpty {
      reversedStr.append(myStack.popLast()!)
   }
   return reversedStr
}

let originalStr = "Learn String"
let resultantString = reverseStringUsingStack(str: originalStr)

print("Original String:", originalStr)
print("Reversed String:", resultantString)

输出

Original String: Learn String
Reversed String: gnirtS nraeL

示例 2

在以下 Swift 程序中，我们将使用栈保留一个字符串。因此，我们使用基于结构的实现来实现栈。在这里，我们定义了一个带有 push、pop 和 isEmpty 方法的结构。然后创建一个函数，在其中我们创建一个栈结构的实例并将输入字符串的所有字符压入栈中，然后以相反的顺序弹出它们以创建反转后的字符串。

import Foundation
import Glibc

// Implementing stack using structure
struct myStack<T> {
   private var item = [T]()
    
   mutating func push(_ items: T) {
      item.append(items)
   }
    
   mutating func pop() -> T? {
      return item.popLast()
   }
    
   func isEmpty() -> Bool {
      return item.isEmpty
   }
}

func reverseString(inputStr: String) -> String {
   var stack = myStack<Character>()
    
   for c in inputStr {
      stack.push(c)
   }
    
   var resultantStr = ""
    
   while !stack.isEmpty() {
      if let c = stack.pop() {
         resultantStr.append(c)
      }
   } 
   return resultantStr
}

let Str = "My cas color is green"
let reversedString = reverseString(inputStr: Str)

print("Input String is: \(Str)")
print("Reversed String is: \(reversedString)")

输出

Input String is: My cas color is green
Reversed String is: neerg si roloc sac yM

结论

这就是我们如何使用栈反转字符串。尽管 Swift 不支持任何内置的栈数据结构，但我们仍然可以通过多种方式实现栈，例如链接列表、结构、类、数组等。在所有这些方法中，实现栈最简单和最直接的方法是数组。