C语言：实现有序序列判断

题目：

输入一个整数序列，判断是否是有序序列，有序，指序列中的整数从小到大排序或者从大到小排序(相同元素也视为有序)。

               

输入描述：

第一行输入一个整数N (3≤N≤50) 。

第二行输入N个整数，用空格分隔N个整数。

                            

输出描述：

输出为一行，如果序列有序输出sorted，否则输出unsorted。

           

示例1：

输入：

5
1 6 9 22 30

输出：

sorted

示例2：

输入：

5
3 4 7 2 10

输出：

unsorted

示例3：

输入：

5
1 1 1 1 1

输出：

sorted

                    

 =========================================================================

                       

思路一：先输入数据再判断

总体思路：

（一）.

输入数组长度N；输入N个整数，用一个数组存储

              

（二）.

判断是否有序：升序 或 降序，

有序的情况下，都是大于号 或 都是小于号。

             

用 两个变量 来分别表示 升序 和 降序：

int flag1 = 0;        --        表升序，满足升序关系 即 flag1 = 1

int flag2 = 0;        --        表降序，满足降序关系 即 flag2 = 1

等于的话，flag1 和 flag2 都是 0

              

相邻两个数进行比较，N个数 就 比较 n-1 对：

使用 for循环 循环进行比较，

for循环 内使用 if条件判断语句，

判断 前一个数 小于 后一个数，还是 前一个数 大于 后一个数，

小于 则 flag1 = 1 ，即 当前两个数是小于号，可能是升序；

大于 则 flag2 = 1 ，即 当前两个数是大于号，可能是降序。

                   

（三）. 

判断完 升序 或 降序 后，看 flag1 和 flag2 的情况来判断是否有序：

               

如果 flag1 + flag2 == 2，说明 既有大于号又有小于号，打印 unsorted ；

其他情况：

flag1 + flag2 == 1的话，说明有序；

flag1 + flag2 == 0的话，说明都相等，也是有序，打印 sorted 。

                

---

                 

第一步：

（1）. 输入数组长度N

              

（2）. 输入N个整数，用一个数组进行存储

                     

实现代码：

#include 
int main()
{
	//输入数组长度N：
	int N = 0; //数组长度
	//输入：
	scanf("%d", &N);

	//输入N个整数，用一个数组进行存储：
	int arr[50] = { 0 };
	//输入N个整数：
	int i = 0;
	for (i = 0; i < N; i++)
	{
		scanf("%d", &arr[i]);
	}


	return 0;
}

实现图片：

                 

---

                 

第二步：

判断是否有序：升序 或 降序，

有序的情况下，都是大于号 或 都是小于号。

             

（1）.

用 两个变量 来分别表示 升序 和 降序：

int flag1 = 0;        --        表升序，满足升序关系 即 flag1 = 1

int flag2 = 0;        --        表降序，满足降序关系 即 flag2 = 1

等于的话，flag1 和 flag2 都是 0

              

（2）.

相邻两个数进行比较，N个数 就 比较 n-1 对：

使用 for循环 循环进行比较，

for循环 内使用 if条件判断语句，

判断 前一个数 小于 后一个数，还是 前一个数 大于 后一个数，

小于 则 flag1 = 1 ，即 当前两个数是小于号，可能是升序；

大于 则 flag2 = 1 ，即 当前两个数是大于号，可能是降序。

                     

实现代码：

#include 
int main()
{
	//输入数组长度N：
	int N = 0; //数组长度
	//输入：
	scanf("%d", &N);

	//输入N个整数，用一个数组进行存储：
	int arr[50] = { 0 };
	//输入N个整数：
	int i = 0;
	for (i = 0; i < N; i++)
	{
		scanf("%d", &arr[i]);
	}

	//判断是否有序：升序 或 降序
	//有序的情况下，都是 大于号 或 都是 小于号

	int flag1 = 0; //表示升序，满足升序关系 --> flag1=1
	int flag2 = 0; //表示降序，满足降序关系 --> flag2=1
	//判断过程中，
	//如果 flag1一直为1，flag2一直为0，说明是升序，
	//如果 flag2一直为1，flag1一直为0，说明是降序
	//等于的话，flag1和flag2都是0

	//相邻两个数进行比较，N个数，比较 N-1 对：
	for (i = 0; i < N-1; i++)
	{
		if (arr[i] < arr[i + 1])
		//前一个数 小于 后一个数
		{
			flag1 = 1;
			//满足升序条件
		}
		else if (arr[i] > arr[i + 1])
		//前一个数 大于 后一个数
		{
			flag2 = 1;
			//满足降序条件
		}
	}

	return 0;
}

实现图片：

                 

---

                 

第三步：

判断完 升序 或 降序 后，看 flag1 和 flag2 的情况来判断是否有序：

               

如果 flag1 + flag2 == 2，说明 既有大于号又有小于号，打印 unsorted ；

其他情况：

flag1 + flag2 == 1的话，说明有序；

flag1 + flag2 == 0的话，说明都相等，也是有序，打印 sorted 。

                     

实现代码：

#include 
int main()
{
	//输入数组长度N：
	int N = 0; //数组长度
	//输入：
	scanf("%d", &N);

	//输入N个整数，用一个数组进行存储：
	int arr[50] = { 0 };
	//输入N个整数：
	int i = 0;
	for (i = 0; i < N; i++)
	{
		scanf("%d", &arr[i]);
	}

	//判断是否有序：升序 或 降序
	//有序的情况下，都是 大于号 或 都是 小于号

	int flag1 = 0; //表示升序，满足升序关系 --> flag1=1
	int flag2 = 0; //表示降序，满足降序关系 --> flag2=1
	//判断过程中，
	//如果 flag1一直为1，flag2一直为0，说明是升序，
	//如果 flag2一直为1，flag1一直为0，说明是降序
	//等于的话，flag1和flag2都是0

	//相邻两个数进行比较，N个数，比较 N-1 对：
	for (i = 0; i < N-1; i++)
	{
		if (arr[i] < arr[i + 1])
		//前一个数 小于 后一个数
		{
			flag1 = 1;
			//满足升序条件
		}
		else if (arr[i] > arr[i + 1])
		//前一个数 大于 后一个数
		{
			flag2 = 1;
			//满足降序条件
		}
	}

	//判断完 升序 或 降序 后，看 flag1 和 flag2 的情况来判断是否有序：
	if (flag1 + flag2 == 2)//说明既有 大于 又有 小于
	{
		printf("unsorted\n");
	}
	else
	// ==1 的话，说明有序；==0 的话，说明都相等，也是有序
	{
		printf("sorted\n");
	}

	return 0;
}

实现图片：

                    

思路一：最终代码和实现效果

最终代码：

#include 
int main()
{
	//输入数组长度N：
	int N = 0; //数组长度
	//输入：
	scanf("%d", &N);

	//输入N个整数，用一个数组进行存储：
	int arr[50] = { 0 };
	//输入N个整数：
	int i = 0;
	for (i = 0; i < N; i++)
	{
		scanf("%d", &arr[i]);
	}

	//判断是否有序：升序 或 降序
	//有序的情况下，都是 大于号 或 都是 小于号

	int flag1 = 0; //表示升序，满足升序关系 --> flag1=1
	int flag2 = 0; //表示降序，满足降序关系 --> flag2=1
	//判断过程中，
	//如果 flag1一直为1，flag2一直为0，说明是升序，
	//如果 flag2一直为1，flag1一直为0，说明是降序
	//等于的话，flag1和flag2都是0

	//相邻两个数进行比较，N个数，比较 N-1 对：
	for (i = 0; i < N-1; i++)
	{
		if (arr[i] < arr[i + 1])
		//前一个数 小于 后一个数
		{
			flag1 = 1;
			//满足升序条件
		}
		else if (arr[i] > arr[i + 1])
		//前一个数 大于 后一个数
		{
			flag2 = 1;
			//满足降序条件
		}
	}

	//判断完 升序 或 降序 后，看 flag1 和 flag2 的情况来判断是否有序：
	if (flag1 + flag2 == 2)//说明既有 大于 又有 小于
	{
		printf("unsorted\n");
	}
	else
	// ==1 的话，说明有序；==0 的话，说明都相等，也是有序
	{
		printf("sorted\n");
	}

	return 0;
}

实现效果：

                    

 =========================================================================

                       

思路二：边输入边判断

（输入两个数后就可以判断一次大小了）

总体思路：

在思路一的基础上：

             

把 思路一第一步的（2）输入N个数

放到 第二步（2）的 for循环中 ，

          

如果输入了两个数就开始进行比较

                

---

              

第一步：

（1）.

把 思路一第一步的（2）输入N个数

放到 第二步（2）的 for循环中 ，

          

（2）.

如果输入了两个数就开始进行比较

                     

实现代码：

#include 
int main()
{
	//输入数组长度N：
	int N = 0; //数组长度
	//输入：
	scanf("%d", &N);

	//输入N个整数，用一个数组进行存储：
	int arr[50] = { 0 };

	//判断是否有序：升序 或 降序
	//有序的情况下，都是 大于号 或 都是 小于号

	int flag1 = 0; //表示升序，满足升序关系 --> flag1=1
	int flag2 = 0; //表示降序，满足降序关系 --> flag2=1
	//判断过程中，
	//如果 flag1一直为1，flag2一直为0，说明是升序，
	//如果 flag2一直为1，flag1一直为0，说明是降序
	//等于的话，flag1和flag2都是0

	int i = 0;
	for (i = 0; i < N; i++)
	{
		//输入：
		scanf("%d", &arr[i]);

		//输入了两个数后就开始比较
		if (i >= 1)
		// i=1 说明输入了 arr[0] 和 arr[1] ,已经输入了两个数
		{
			if (arr[i] < arr[i - 1])
				//因为进来后 i 以及是下标1了，还要判断下标0，arr[0]
				//一个数 小于 前一个数
			{
				flag1 = 1;
				//满足升序条件
			}
			else if (arr[i] > arr[i + 1])
				//一个数 大于 后一个数
			{
				flag2 = 1;
				//满足降序条件
			}
		}

	}

	//判断完 升序 或 降序 后，看 flag1 和 flag2 的情况来判断是否有序：
	if (flag1 + flag2 == 2)//说明既有 大于 又有 小于
	{
		printf("unsorted\n");
	}
	else
		// ==1 的话，说明有序；==0 的话，说明都相等，也是有序
	{
		printf("sorted\n");
	}

	return 0;
}

实现图片：

                    

思路二：最终代码和实现效果

最终代码：

#include 
int main()
{
	//输入数组长度N：
	int N = 0; //数组长度
	//输入：
	scanf("%d", &N);

	//输入N个整数，用一个数组进行存储：
	int arr[50] = { 0 };

	//判断是否有序：升序 或 降序
	//有序的情况下，都是 大于号 或 都是 小于号

	int flag1 = 0; //表示升序，满足升序关系 --> flag1=1
	int flag2 = 0; //表示降序，满足降序关系 --> flag2=1
	//判断过程中，
	//如果 flag1一直为1，flag2一直为0，说明是升序，
	//如果 flag2一直为1，flag1一直为0，说明是降序
	//等于的话，flag1和flag2都是0

	int i = 0;
	for (i = 0; i < N; i++)
	{
		//输入：
		scanf("%d", &arr[i]);

		//输入了两个数后就开始比较
		if (i >= 1)
		// i=1 说明输入了 arr[0] 和 arr[1] ,已经输入了两个数
		{
			if (arr[i] < arr[i - 1])
				//因为进来后 i 以及是下标1了，还要判断下标0，arr[0]
				//一个数 小于 前一个数
			{
				flag1 = 1;
				//满足升序条件
			}
			else if (arr[i] > arr[i + 1])
				//一个数 大于 后一个数
			{
				flag2 = 1;
				//满足降序条件
			}
		}

	}

	//判断完 升序 或 降序 后，看 flag1 和 flag2 的情况来判断是否有序：
	if (flag1 + flag2 == 2)//说明既有 大于 又有 小于
	{
		printf("unsorted\n");
	}
	else
		// ==1 的话，说明有序；==0 的话，说明都相等，也是有序
	{
		printf("sorted\n");
	}

	return 0;
}

实现效果：