1
2
3
4
5
6
7
8
9
10
11
      //顺序查找法，实质是遍历数组一一比较；
	for (Index = 0; Index < N; Index++)
	{
		if (a[Index] == X)
		{
			flag = 1;//此时表示已经找到
			loc = Index;
		}
	}
      //为了输出方便一般会另设一个标记变量来标记找到与否。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//假设存在数组a[]，find表示要找的数，left表示左界的下标，right表示右界的下标。
	while (left <= right)
    //这种情况下相等的情况也要考虑，而且往往找到的情况是left = right = middle的情况！
	{
		middle = (left + right) / 2;
		if (find == a[middle])
		{
			printf("这个数是第%d个数", middle + 1);
			break;
		}
		else if (find > a[middle])
		{
			left = middle + 1;
		}
		else
		{
			right = middle - 1;
		}
	}

	if (left > right)
	{
		printf("找不到这个数");
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
      //判断代码可以插入的位置；
	for (count = 0; count < numbN; count++)
	{
		if (numbX > a[count])
		{
			loc = count + 1;
		}
	}
	//将数组中从这个位置开始向后移；
	for (countChange = numbN; countChange > loc; countChange--)
	{
		a[countChange] = a[countChange - 1];
	}
	a[loc] = numbX;

1
2
3
4
5
6
7
8
9
10
11
	scanf("%d", &k);//这里的k表示删除的次数；
	for (i = 0; i < k; i++)
	{
		scanf("%d", &order);//order表示想删除的数的位置；
		for (j = order - 1; j < n; j++)
		{
			array[j] = array[j + 1];
		}
		n--;
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
	//数据表达
	unsigned int n;
	int a[11];//数组a；
	int Index = 0;//控制数组输入的下标;
	int count = 0;//计数当前刷过几遍；
	int temp;//用于存储暂时的变量；
	int bigIndex;//用来表示更大数的下标；
        //选择法排序1；
	for (count = 0; count < n - 1; count++)
	{
		bigIndex = count;//表示最大数的下标 并在每一轮先表示那一轮内循环的第一个数；
		for (Index = count; Index < n - 1; Index++)
		{
			if (a[bigIndex] < a[Index + 1])//以本循环内的第一个数为起始点，不断与下一个数进行大小比较；
			{
				bigIndex = Index + 1;//用一个下标变量来定位最大的那个数；
			}
			else;
		}
		//将最大数交换到当前的第一个数的位置来，然后把当前第一个数的换到原本最大数的那个位置；
		temp = a[count]; 
		a[count] = a[bigIndex];
		a[bigIndex] = temp;
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
	//选择法排序2；
	for (count = 0; count < n - 1; count++)
	{
		bigIndex = count;//表示最大数的下标再每一轮先表示那一轮内循环的第一个数；
		for (Index = count + 1 ; Index < n; Index++)
		{
			if (a[bigIndex] < a[Index])//以本循环内的第一个数为起始点，不断与下一个数进行大小比较；
			{
				bigIndex = Index;//用一个下标变量来定位最大的那个数；
			}
			else;
		}
		//将最大数交换到当前的第一个数的位置来，然后把当前第一个数的换到原本最大数的那个位置；
		temp = a[count]; 
		a[count] = a[bigIndex];
		a[bigIndex] = temp;
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
      //数据表达
	unsigned long int N;
	unsigned long int K;
	int a[101];//数组a；
	int Index = 0;//控制数组的下标；
	int count = 0;//计数当前刷过几遍；
	int temp;//用于存储暂时的变量；
	//冒泡法排序；
	for (count = 0; count < K ; count++)//这里表示一共做冒泡法的轮数，K的表达形式与count的初值有关！
	{
		for (Index = 0; Index < N - count-1; Index++)//这里面的   N - count-1 很重要！！！-1是保证数组下标不越界；
		{
			if (a[Index] > a[Index + 1])
			{
				temp = a[Index + 1];  a[Index + 1] = a[Index];	a[Index] = temp;//做交换；           
				//要记住交换的    传递性   写法！！
				//这样写一是可以的：  temp = a[Index];   a[Index] = a[Index + 1];   a[Index] = temp;
				//记住一个看起来的特点那便是：首 尾 顶 真 ！
			}
		}
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include<stdio.h>
int main()
{
	int n;
	int i, j;
	scanf("%d", &n);
	int array[9][9];
	for (i = 0; i < n; i++)
	{
		for (j = 0; j <= i; j++)
		{
			if (i == j || j == 0)
			{
				array[i][j] = 1;
			}
			else
			{
				array[i][j] = array[i - 1][j - 1] + array[i - 1][j];
			}
		}
	}

	for (i = 0; i < n; i++)
	{
		for (j = 0; j <= i; j++)
		{
			printf("%4d", array[i][j]);
		}
		printf("n");
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
//这是过不了审的用了循环嵌套的做法：
int main()
{
	//数据表达
	int n, i, k;
	int numbers[100000];
	int numbers1[100000];
	int count = 0;
	//流程设计
	//input
	scanf("%d", &n);
	for (i = 0; i < n; i++)
	{
		scanf("%d", &numbers[i]);
	}
	
	for (i = 0; i < n; i++)
	{
		for (k = i; k < n; k++)
		{
			if (numbers[i] == numbers[k])
			{
				count++;
			}
		}
	}

	if (count >= 2)
	{
		printf("YES");
	}
	else
	{
		printf("NO");
	}

	return 0;
}
/* 用这种方法来解决  有重复的数据I 过不了数字很大的 测试点。但是这个方法是有值得学习的地方的
那就是对数组的一种思考方式：==那就是可以通过定义两个在改变的不同变量来当作同一数组的下标使用
数组。== */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
//于是有了哈希数组的方法：
int main()
{
	//数据表达
	int n, i;
	int numbers[100000];//内数组用来存放实际元素；
	static int numbers1[100001];//外数组用来统计个数。
	int flag = 1;
	//流程设计
	scanf("%d", &n);
	for (i = 0; i < n; i++)
	{
		scanf("%d", &numbers[i]);
	}

	for (i = 0; i < n; i++)
	{
		numbers1[numbers[i]]++;
	}

	for (i = 0; i < n; i++)
	{
		if (numbers1[numbers[i]] >= 2)
		{
			flag = 0;
		}
	}

	if (flag)
	{
		printf("NO");
	}
	else
	{
		printf("YES");
	}

	return 0;
}

1
2
3
4
      //假设此刻有一个字符数组为a
      scanf("%s",a)；
      //其中字符数组的变量名本身就代表首地址所以不需要 & ，其次不需要[]。

1
2
3
4
5
6
7
      //这里假设输入一串字符并用 回车 来结束输入：
      while （(str[i]=getchar()) != 'n'）
      {
            i++;
      }
      str[i] = '';

1
2
for (i = 0；str[i]；i++)  putchar（str[i]）;

1
2
3
printf("%s,str");
printf("%s","How are you?");

1
2
3
puts(str);
puts("How are you?");

1
2
3
4
5
6
7
8
用scanf语句输入T
再在while语句(while(T--))内分别对T个矩阵进行输入；
每输入完成一个矩阵后，再接一个循环这个循环用来判断是不是上三角矩阵
if count1(row) > count2(col)   存在matrix[count1][count2] ！= 0 
那就说明这个矩阵不是上三角矩阵 ，让flag[count3] = 1（默认flag[] = 0为是上三角）；
count3用来表示待测矩阵的序数，每次 T减1,它就加1。
最后统一输出当flag[]等于0时输出YES，当flag[]等于1时输出NO。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
用状态变量flag = 1来区分是否找到鞍点的情况。当下表示有鞍点
scanf输入n
for from j = 0 to n 
      for from i = 0 to n
            scanf array[j][i]
for from i = 0 to n
      flag = 1 每一次从新的一行开始，状态变量都应该更新为默认有鞍点存在的状态。
      col = i;
      for from j = 1 to n
            比较array[i][col] <= array[i][j] 查找看是否同一行最大的那个元素的列下标，
            由此找到行最大 col = j;  加等号是为了保证极值并列的情况下，取后一个数为鞍点。
      for from x = 0 to n
            比较array[i][col] > array[x][col] 查找行最大的这个下标对应的元素在其所在的列是否为最小，
            如果不是的话 flag = 0；
      在循环最后同过flag的值来判断这一轮寻找是否有找到鞍点，如果有的话，row = i 并 结束循环
循环外进行统一输出，以状态变量为条件分别控制有无鞍点情况的输出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
//找鞍点
#include<stdio.h>
int main()
{
	//数据表达
	int n;
	int i, j, x;
	int array[6][6];
	int col, row;
	int flag = 1;//用来表示是否存在鞍点；
	//流程设计

	//input：
	scanf("%d", &n);
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < n; j++)
		{
			scanf("%d", &array[i][j]);
		}
	}

	//judgement:
	for (i = 0; i < n; i++)
	{
		flag = 1;//每一行开始的起始都应该怀着可能找到鞍点的状态；
		col = 0;
		//找到本行最大的那个数的列下标；
		for (j = 1; j < n; j++)
		{
			if (array[i][col] <= array[i][j])
			//加上等号是如果遇到一样大的，取后面的，不取前面的。
			{
				col = j;
			}
		}

		//拿这行下下标最大的数和它所在列的其他数进行对比；
		for (x = 0; x < n; x++)
		{
			if (array[i][col] > array[x][col] && x != i)
			{
				flag = 0;/*如果在该列中存在比这个行最大的数小的数，
				那就说明，这个行最大的数不是鞍点。*/
                break;//这是分析老师的代码之后加上去提高效率的。
			}
		}

		//即时跳出有鞍点的情况
		if (flag == 1)
		{
			row = i;
			break;
		}
	}

	if (flag)
	{
		printf("%d %d", row, col);
	}
	else
	{
		printf("NONE");
	}

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
//找鞍点
#include<stdio.h>
int main()
{
	//数据表达
	int n;
	int i, j, x;
	int array[6][6];
	int col, row;
	int flag = 1;//用来表示是否存在鞍点；
	//流程设计

	//input：
	scanf("%d", &n);
	for (i = 0; i < n; i++)
	{
		for (j = 0; j < n; j++)
		{
			scanf("%d", &array[i][j]);
		}
	}
	//judgement:
	for (i = 0; i < n; i++)
	{
		flag = 1;//每一行开始的起始都应该怀着可能找到鞍点的状态；
		col = 0;
		//找到本行最大的那个数的列下标；
		for (j = 1; j < n; j++)
		{
			if (array[i][col] <= array[i][j])
				//加上等号是如果遇到一样大的，取后面的，不取前面的。
			{
				col = j;
			}
		}
		//查找是否存在并列最大的情况。
		int cols[6];
		int col_numb = 0;
		for (j = 0; j < n; j++)
		{
			if (array[i][col] == array[i][j])
			{
				cols[col_numb++] = j;
			}
		}

		int cur_col = 0;
		for (cur_col; cur_col < col_numb; cur_col++)
		{
			flag = 1;//每一个并列极值下标开始的起始都应该怀着可能找到鞍点的状态；
			//拿这行下下标最大的数和它所在列的其他数进行对比；
			for (x = 0; x < n; x++)
			{
				if (array[i][cols[cur_col]] > array[x][cols[cur_col]] && x != i)
				{
					flag = 0;/*如果在该列中存在比这个行最大的数小的数，
					那就说明，这个行最大的数不是鞍点。*/
					break;//这是分析老师的代码之后加上去提高效率的。
				}
			}
			//即时跳出有鞍点的情况
			if (flag == 1)
			{
				col = cols[cur_col];
				row = i;
				break;
			}
		}
		if (flag == 1)
		{
			break;
		}
	}

	if (flag)
	{
		printf("%d %d", row, col);
	}
	else
	{
		printf("NONE");
	}
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
用scanf进行输入这一串表达式
然后首先对数字进行判定，
if 输入的是数字的话进行如下判定
      if下一个字符是结束字符''的话，那也不换行
      else if下一个字符是其他字符 且 这个字符不是小数点的话就直接换行
      else 下一个字符是数字或者小数点都不换行。
else if是对比较特殊的减号进行判定
      if减号在开头的话，那就不换行
      else if如果减号前面的字符不是数字 且 i = 0的话，那就不换行
      else 这时候充当的是减号那就换行。
else if是对加号这个特殊的符号进行判断
      if i == 0，输出不换行
      else 输出换行充当加号。
else if 其他的字符
      if 下一个字符是结束字符的话那就不换行
      else 其他全部统统换行输出。