/*
* 【例3-4】编程判断一个字符串是否是回文。
* 回文是指一个字符序列以中间字符为基准两边字符完全相同，
* 如字符序列"ACBDEDBCA"是回文。
* 算法思想：判断一个字符序列是否是回文，就是把第一个字符与最后一个字符相比较，
* 第二个字符与倒数第二个字符比较，依次类推，第i个字符与第n-i个字符比较。
* 如果每次比较都相等，则为回文，如果某次比较不相等，就不是回文。
* 因此，可以把字符序列分别入队列和栈，
* 然后逐个出队列和出栈并比较出队列的字符和出栈的字符是否相等，
* 若全部相等则该字符序列就是回文，否则就不是回文。
*/
public static void palindrome()
{
SeqStack <char> s = new SeqStack <char>(50);
SeqQueue <char> q = new SeqQueue <char>(50);
string str = Console.ReadLine(); //手动输入字符串
for (int i = 0; i < str.Length; ++i) //循环入
{
s.Push(str[i]);
q.In(str[i]);
}
while (!s.IsEmpty() && !q.IsEmpty())//循环出
{
if (s.Pop() != q.Out())
{
break;
}
}
if (!s.IsEmpty() || !q.IsEmpty())//非空
{
Console.WriteLine("这不是回文！");
}
else //空
{
Console.WriteLine("这是回文！");
}
} //public static void Main()
public void EnqueueAndDequeue(int capacity, int items)
{
var seed = 53134;
var q = new SeqQueue <T>(capacity);
Assert.Empty(q);
// Enqueue some values and make sure the count is correct
var source = (List <T>)CreateEnumerable(EnumerableType.List, null, items, 0, 0);
foreach (var val in source)
{
q.Enqueue(val);
}
Assert.Equal(source, q);
// Dequeue to make sure the values are removed in the right order and the count is updated
for (var i = 0; i < items; i++)
{
var itemToRemove = source[0];
source.RemoveAt(0);
Assert.Equal(itemToRemove, q.Dequeue());
Assert.Equal(items - i - 1, q.Count);
}
// Can't dequeue when empty
Assert.Throws <InvalidOperationException>(() => q.Dequeue());
// But can still be used after a failure and after bouncing at empty
var itemToAdd = CreateT(seed++);
q.Enqueue(itemToAdd);
Assert.Equal(itemToAdd, q.Dequeue());
}
public void Constructor_IEnumerable(EnumerableType enumerableType, int setLength, int enumerableLength, int numberOfMatchingElements, int numberOfDuplicateElements)
{
var enumerable = CreateEnumerable(enumerableType, null, enumerableLength, 0, numberOfDuplicateElements);
var queue = new SeqQueue <T>(enumerable);
Assert.Equal(enumerable, queue);
}
public void Constructor_int(int count)
{
var queue = new SeqQueue <T>(count);
Assert.Equal(new T[0], queue.ToArray());
queue.Clear();
Assert.Equal(new T[0], queue.ToArray());
}
public void ToArray_NonWrappedQueue(int count)
{
var collection = new SeqQueue <T>(count + 1);
AddToCollection(collection, count);
var elements = collection.ToArray();
elements.Reverse();
Assert.True(Enumerable.SequenceEqual(elements, collection.ToArray <T>()));
}
public void getRearTest()
{
SeqQueue <string> seqQueue = new SeqQueue <string>(10);
seqQueue.enter("A");
seqQueue.enter("B");
seqQueue.enter("C");
seqQueue.enter("D");
Assert.AreEqual(seqQueue.getRear(), "D");
}
protected SeqQueue <T> GenericQueueFactory(int count)
{
var queue = new SeqQueue <T>(count);
var seed = count * 34;
for (var i = 0; i < count; i++)
{
queue.Enqueue(CreateT(seed++));
}
return(queue);
}
public void exitTest()
{
SeqQueue <string> seqQueue = new SeqQueue <string>(10);
seqQueue.enter("A");
seqQueue.enter("B");
seqQueue.enter("C");
seqQueue.enter("D");
seqQueue.enter("F");
Assert.AreEqual(seqQueue.exit(), "A");
}
public void clearTest()
{
SeqQueue <string> seqQueue = new SeqQueue <string>(10);
seqQueue.enter("A");
seqQueue.enter("B");
seqQueue.enter("C");
seqQueue.enter("D");
seqQueue.clear();
Assert.AreEqual(seqQueue.isEmpty, true);
}
void Start()
{
SeqQueue <int> seqQueue = new SeqQueue <int>();
for (int i = 0; i < 3; i++)
{
seqQueue.Enqueue(i);
}
print("展示队列顶元素:" + seqQueue.Peek());
print("队列数量:" + seqQueue.Length());
for (int i = 0; i < 3; i++)
{
print(seqQueue.Dequeue());
}
}
public void enterTest()
{
SeqQueue <string> seqQueue = new SeqQueue <string>(10);
seqQueue.enter("A");
seqQueue.enter("B");
seqQueue.enter("C");
seqQueue.enter("D");
seqQueue.enter("E");
List <string> result = new List <string>()
{
"A", "B", "C", "D", "E"
};
CollectionAssert.AreEqual(seqQueue.display(), result);
}
//层序遍历（Level Order）
public void LevelOrder(Node <T> root)
{
if (root == null)
{
return;
}
SeqQueue <Node <T> > sq = new SeqQueue <Node <T> >(50);
sq.Enqueue(root);//根结点入队
while (!sq.IsEmpty())
{
Node <T> temp = sq.Dequeue(); //结点出队
Console.WriteLine(temp.Data); //处理当前结点
if (temp.LChild != null)
{
sq.Enqueue(temp.LChild);
}
if (temp.RChild != null)
{
sq.Enqueue(temp.RChild);
}
}
}
