最好的自动换行算法？ [关闭]

自动换行是现代文本编辑器的必备功能之一。

如何处理自动换行？最好的自动换行算法是什么？

如果文本有几百万行，如何才能快速自动换行？

为什么我需要解决方案？因为我的项目必须绘制具有各种缩放级别的文本，同时具有美观的外观。

运行环境为Windows Mobile设备。最大速度为 600 MHz，内存容量非常小。

我应该如何处理线路信息？我们假设原始数据有三行。

THIS IS LINE 1.
THIS IS LINE 2.
THIS IS LINE 3.

之后，中断文本将显示如下：

THIS IS
LINE 1.
THIS IS
LINE 2.
THIS IS
LINE 3.

我应该多分配三行吗？或者还有其他建议吗？ ­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­

这是我用 C# 编写的自动换行算法。
翻译成其他语言应该相当容易（也许除了IndexOfAny).

static char[] splitChars = new char[] { ' ', '-', '\t' };

private static string WordWrap(string str, int width)
{
    string[] words = Explode(str, splitChars);

    int curLineLength = 0;
    StringBuilder strBuilder = new StringBuilder();
    for(int i = 0; i < words.Length; i += 1)
    {
        string word = words[i];
        // If adding the new word to the current line would be too long,
        // then put it on a new line (and split it up if it's too long).
        if (curLineLength + word.Length > width)
        {
            // Only move down to a new line if we have text on the current line.
            // Avoids situation where
            // wrapped whitespace causes emptylines in text.
            if (curLineLength > 0)
            {
                strBuilder.Append(Environment.NewLine);
                curLineLength = 0;
            }

            // If the current word is too long
            // to fit on a line (even on its own),
            // then split the word up.
            while (word.Length > width)
            {
                strBuilder.Append(word.Substring(0, width - 1) + "-");
                word = word.Substring(width - 1);

                strBuilder.Append(Environment.NewLine);
            }

            // Remove leading whitespace from the word,
            // so the new line starts flush to the left.
            word = word.TrimStart();
        }
        strBuilder.Append(word);
        curLineLength += word.Length;
    }

    return strBuilder.ToString();
}

private static string[] Explode(string str, char[] splitChars)
{
    List<string> parts = new List<string>();
    int startIndex = 0;
    while (true)
    {
        int index = str.IndexOfAny(splitChars, startIndex);
        
        if (index == -1)
        {
            parts.Add(str.Substring(startIndex));
            return parts.ToArray();
        }

        string word = str.Substring(startIndex, index - startIndex);
        char nextChar = str.Substring(index, 1)[0];
        // Dashes and the like should stick to the word occuring before it.
        // Whitespace doesn't have to.
        if (char.IsWhiteSpace(nextChar))
        {
            parts.Add(word);
            parts.Add(nextChar.ToString());
        }
        else
        {
            parts.Add(word + nextChar);
        }

        startIndex = index + 1;
    }
}

它相当原始——它按空格、制表符和破折号进行分割。

它确实确保破折号粘在它之前的单词上 （所以你不会最终得到“堆栈
-溢出”）， 虽然它不利于移动小连字符的单词 到一个新行而不是拆分它们。

如果单词对于一行来说太长，它确实会分割单词。

它也具有相当的文化特色， 因为我不太了解其他文化的自动换行规则。