冒泡排序

Think:
1冒泡排序内在思想的两种实现方法

sdut题目链接

冒泡排序
Time Limit: 1000MS Memory Limit: 65536KB

Problem Description
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

冒泡排序算法的运作如下：（从右往左）
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

或者从左往右:
比较相邻的元素。如果第二个比第一个小，就交换他们两个。
对每一对相邻元素作同样的工作，从结尾最后一对到开始的第一对。在这一点，最左端的元素应该会是最小的数。
针对所有的元素重复以上的步骤，除了第一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

现在有一个n个数组成的原始序列。
小白在手动对其进行冒泡，因种种原因中途离开了一会，回来以后发现忘记用的哪种冒泡顺序了！
现在他向你求助，你能帮他判断出这是从左往右还是从右往左的冒泡排序么？
默认小白离开时，已将当前层迭代完毕。

Input

多组输入。
每组输入在第一行给出正整数N (0 < N <=100)；随后一行给出原始序列的N个整数；
之后给出由冒泡排序算法产生的中间序列。这里假设排序的目标序列是升序。数字间以空格分隔。

Output
对应每组输入，输出一行字符串为答案。
如果是从左往右的冒泡排序，输出”Left To Right”
如果是从右往左的冒泡排序，输出”Right To Left”
如果两种冒泡都可以，输出”Dou Ke Yi”
如果两种冒泡都不会产生这个中间序列，输出”No Way”
（输出均不包含引号）

Example Input

3
3 2 1
2 1 3
3
3 2 1
1 3 2
3
1 2 3
1 2 3
3
3 2 1
2 3 1

Example Output

Right To Left
Left To Right
Dou Ke Yi
No Way

Hint

Author
LeiQ

以下为Accepted代码

#include <stdio.h>

int u[104], v[104], a[104];

int main()
{
    int n, i, j, t, cnt, flag;
    while(scanf("%d", &n) != EOF){
        cnt = 0, flag = 0;
        for(i = 0; i < n; i++){
            scanf("%d", &v[i]);
            u[i] = v[i];//两个数组记录，分别进行两种冒泡排序
        }

        for(i = 0; i < n; i++){
            scanf("%d", &a[i]);//数组记录需要判断的序列的元素
        }

        cnt = 1, flag = 1;//cnt变量标记第一种冒泡排序，flag变量标记第二种冒泡排序

        ///第一种情况，可能最初给定需要判断的序列即是原始序列
        for(i = 0; i < n; i++){
            if(u[i] != a[i]){
                 cnt = 0, flag = 0;
                 break;
            }
        }

        ///判断是否可由第一种冒泡排序得到目标序列
        if(cnt == 0){
            for(i = 0; i < n; i++)///控制冒泡排序的次数，可优化
            {
                for(j = 0; j < n-i-1; j++)///从最左边开始排序，目标是将最大值浮到最右边
                {
                    if(u[j] > u[j+1])///比较排序
                        t = u[j], u[j] = u[j+1], u[j+1] = t;
                }

                ///判断当前得到的序列是否为目标序列
                cnt = 1;
                for(j = 0; j < n; j++)
                {
                    if(u[j] != a[j]){
                        cnt = 0;
                        break;
                    }
                }
                if(cnt)///及时结束外层循环，避免标记变量错误更新
                    break;
            }
        }

        ///判断是否可由第二种冒泡排序得到目标序列
        if(flag == 0){
            for(i = 0; i < n; i++)///控制冒泡排序的次数，可优化
            {
                for(j = n-1; j > i; j--)///从最左边开始排序，目标是将最小值浮到最左边
                {
                    if(v[j] < v[j-1])///比较排序
                        t = v[j], v[j] = v[j-1], v[j-1] = t;
                }

                ///判断当前得到的序列是否为目标序列
                flag = 1;
                for(j = 0; j < n; j++)
                {
                    if(v[j] != a[j]){
                        flag = 0;
                        break;
                    }
                }
                if(flag)///及时结束外层循环，避免标记变量错误更新
                    break;
            }
        }

        if(cnt && flag)///两种冒泡排序都可以得到的情况
            printf("Dou Ke Yi\n");
        else if(cnt && flag == 0)///只有第一种冒泡排序可以得到的情况
            printf("Right To Left\n");
        else if(cnt == 0 && flag)
            printf("Left To Right\n");///只有第二种冒泡排序可以得到的情况
        else if(cnt == 0 && flag == 0)///两种冒泡排序都无法得到的情况
            printf("No Way\n");
    }
    return 0;
}