C#实现字符串倒序遍历的方法小结

2024-02-18 08:28:43 作者：wenchm

这篇文章主要为大家详细介绍了C#中实现字符串倒序遍历的常见方法,文中的示例代码讲解详细,具有一定的借鉴价值,有需要的小伙伴可以参考下

1.使用Reverse()方法

实现字符串的倒序遍历，可以使用Enumerable.Reverse<TSource>(IEnumerable<TSource>) 方法。

（1）定义

反转序列中元素的顺序。

using System.Linq;
public static System.Collections.Generic.IEnumerable<TSource> Reverse<TSource> (this System.Collections.Generic.IEnumerable<TSource> source);

类型参数

TSource source 的元素类型。

参数

source IEnumerable<TSource> 要反转的值序列。

IEnumerable<TSource> 一个序列，其元素以相反顺序对应于输入序列的元素。

例如

ArgumentNullException
source 为 null。

（2）示例

// 使用Reverse()方法给字符串倒序遍历
namespace _122_1
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            ArgumentNullException.ThrowIfNull(args);
 
            Console.WriteLine(new string("Hello, World!".Reverse().ToArray()));
        }
    }
}
//运行结果：
/*
!dlroW ,olleH
 */

2.使用for循环

// 使用for循环给字符串倒序遍历
namespace _122_2
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            ArgumentNullException.ThrowIfNull(args);
 
            string input = "Hello, World!";
            string reversed = "";
            for (int i = input.Length - 1; i >= 0; i--)
            {
                reversed += input[i];
            }
            Console.WriteLine(reversed);
        }
    }
}
//运行结果：
/*
!dlroW ,olleH
 */

3.使用IEnumerable()迭代器

使用迭代器实现C#字符串的倒序遍历，可以使用yield关键字创建一个迭代器函数。

（1）示例1

示例创建了一个名为ReverseIterator的迭代器函数。然后，使用for循环从后向前访问字符串中的字符，并使用yield return语句返回每个字符。在Main函数中，使用string.Join方法将迭代器中的字符连接成一个字符串，输出倒序的字符串：!dlroW ,olleH。

// 使用迭代器给字符串倒序遍历
namespace _122_3
{
    class Program
    {
        static void Main(string[] args)
        {
            ArgumentNullException.ThrowIfNull(args);
 
            string input = "Hello, World!";
            string reversed = string.Join("", ReverseIterator(input));
            Console.WriteLine(reversed);
        }
 
        static IEnumerable<char> ReverseIterator(string input)
        {
            for (int i = input.Length - 1; i >= 0; i--)
            {
                yield return input[i];
            }
        }
    }
}
//运行结果：
/*
!dlroW ,olleH
 */

（2）示例2

// 使用迭代器实现倒序遍历
namespace _122
{
    public partial class Form1 : Form
    {
        private Label? label1;
        private Label? label2;
        private TextBox? textBox1;
        private TextBox? textBox2;
        private Button? button1;
 
        public Form1()
        {
            InitializeComponent();
            StartPosition = FormStartPosition.CenterScreen;
            Load += Form1_Load;
        }
 
        private void Form1_Load(object? sender, EventArgs e)
        {
            // 
            // label1
            // 
            label1 = new Label
            {
                AutoSize = true,
                Location = new Point(12, 11),
                Name = "label1",
                Size = new Size(68, 17),
                TabIndex = 0,
                Text = "源字符串："
            };
            // 
            // label2
            // 
            label2 = new Label
            {
                AutoSize = true,
                Location = new Point(12, 40),
                Name = "label2",
                Size = new Size(68, 17),
                TabIndex = 1,
                Text = "倒排结果："
            };
            // 
            // textBox1
            // 
            textBox1 = new TextBox
            {
                Location = new Point(77, 8),
                Name = "textBox1",
                Size = new Size(165, 23),
                TabIndex = 2
            };
            // 
            // textBox2
            // 
            textBox2 = new TextBox
            {
                Location = new Point(77, 34),
                Name = "textBox2",
                Size = new Size(165, 23),
                TabIndex = 3
            };
            // 
            // button1
            // 
            button1 = new Button
            {
                Location = new Point(167, 61),
                Name = "button1",
                Size = new Size(75, 23),
                TabIndex = 4,
                Text = "倒序排列",
                UseVisualStyleBackColor = true
            };
            button1.Click += Button1_Click;
            // 
            // Form1
            // 
            AutoScaleDimensions = new SizeF(7F, 17F);
            AutoScaleMode = AutoScaleMode.Font;
            ClientSize = new Size(254, 96);
            Controls.Add(button1);
            Controls.Add(textBox2);
            Controls.Add(textBox1);
            Controls.Add(label2);
            Controls.Add(label1);
            Name = "Form1";
            Text = "用迭代器实现倒序遍历";
        }
 
        private void Button1_Click(object? sender, EventArgs e)
        {
            textBox2!.Clear();
            textBox2.Text = GetValue(textBox1!.Text);
        }
 
        /// <summary>
        /// 通过迭代器实现字符串的倒序
        /// 从末尾开始遍历字符串
        /// </summary>
        /// <param string="n">进行倒序的字符串</param>
        /// <returns>以对象的方式倒序返回单个字符</returns>
        public static IEnumerable<object> Transpose(string n)
        {
            if (n.Length > 0)           //如果泛型不为空
            {
                for (int i = n.Length - 1; i >= 0; i--)
                    yield return n[i];  //返回数据集合
            }
        }
 
        /// <summary>
        /// 获取倒序后的字符串静态方法
        /// </summary>
        /// <param string="str">进行倒序的字符串</param>
        /// <returns>返回倒序后的字符串</returns>
        public static string GetValue(string str)
        {
            if (str.Length == 0)        //判断字符串长度是否为0
                return "";
            string temp_str = "";       //记录倒序之后的字符串
            foreach (object i in Transpose(str))
                temp_str += i.ToString();//访问接口并获取迭代器中的每个字符
            return temp_str;            //返回倒序之后的字符串
        }
    }
}

4.使用List<T>

使用List<T>来实现字符串的倒序遍历，可以先将字符串转换为字符列表，然后使用Reverse方法对列表进行反转，最后遍历列表以生成倒序字符串。

示例首先将输入字符串转换为字符列表，然后使用Reverse方法对列表进行反转。接着，我们使用foreach循环遍历反转后的字符列表，并将每个字符添加到倒序字符串中。最后，输出倒序字符串：!dlroW ,olleH。

// 使用List<T>给字符串倒序遍历
 
namespace _122_4
{
    class Program
    {
        static void Main(string[] args)
        {
            ArgumentNullException.ThrowIfNull(args);
 
            string input = "Hello, World!";
            List<char> charList = new(input);
            charList.Reverse();
            string reversed = "";
            foreach (char c in charList)
            {
                reversed += c;
            }
            Console.WriteLine(reversed);
        }
    }
}
//运行结果：
/*
!dlroW ,olleH
 */

5.使用List<T>的迭代器

使用List<T>和迭代器来实现字符串的倒序遍历，可以先将字符串转换为字符列表，然后使用迭代器函数从后向前访问字符并返回。

示例首先将输入字符串转换为字符列表。然后，创建了一个名为ReverseIterator的迭代器函数，它接受字符列表作为输入。使用for循环从后向前访问字符列表中的字符，并使用yield return语句返回每个字符。在Main函数中，使用string.Join方法将迭代器中的字符连接成一个字符串，输出倒序的字符串：!dlroW ,olleH。

// 使用List<T>的迭代器给字符串倒序遍历
 
namespace _122_5
{
    class Program
    {
        static void Main(string[] args)
        {
            ArgumentNullException.ThrowIfNull(args);
 
            string input = "Hello, World!";
            List<char> charList = new(input);
            //charList.Reverse();
            string reversed = string.Join("", ReverseIterator(charList));
            Console.WriteLine(reversed);
        }
 
        static IEnumerable<char> ReverseIterator(List<char> charList)
        {
            for (int i = charList.Count - 1; i >= 0; i--)
            {
                yield return charList[i];
            }
        }
    }
}
//运行结果：
/*
!dlroW ,olleH
 */

6.使用IList<T>

使用IList<T>来实现字符串的倒序遍历，可以先将字符串转换为字符列表，然后使用Reverse方法对列表进行反转，最后遍历列表以生成倒序字符串。

示例首先将输入字符串转换为字符列表，并使用Reverse方法对列表进行反转。然后，我们使用for循环从后向前访问字符列表中的字符，并将每个字符添加到倒序字符串中。最后，输出倒序字符串：!dlroW ,olleH。

在这个示例中，使用IList<T>接口而不是List<T>类，这意味着可以使用任何实现了IList<T>接口的类，例如ArrayList。

// 使用IList<T>给字符串倒序遍历
 
namespace _122_6
{
    class Program
    {
        static void Main(string[] args)
        {
            ArgumentNullException.ThrowIfNull(args);
 
            string input = "Hello, World!";
            IList<char> charList = new List<char>(input);
            //charList!.Reverse();
            string reversed = "";
            for (int i = charList.Count - 1; i >= 0; i--)
            {
                reversed += charList[i];
            }
            Console.WriteLine(reversed);
        }
    }
}
//运行结果：
/*
!dlroW ,olleH
 */

7.使用IList<T>的迭代器

使用IList<T>和迭代器来实现字符串的倒序遍历，先将字符串转换为字符列表，然后使用迭代器函数从后向前访问字符并返回。

示例首先将输入字符串转换为字符列表。然后，创建了一个名为ReverseIterator的迭代器函数，它接受一个字符列表作为输入。使用for循环从后向前访问字符列表中的字符，并使用yield return语句返回每个字符。在Main函数中，我们使用string.Join方法将迭代器中的字符连接成一个字符串，输出倒序的字符串：!dlroW ,olleH。