if语句输出由大到小的数字

只看该作者 · 2016-4-30 21:35

成长记录 if语句输出由大到小的数字 ?

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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

#include<stdio.h>
void main()
{
float a,b,c,d,e,f,g,t;
scanf("%f,%f,%f,%f,%f,%f,%f",&a,&b,&c,&d,&e,&f,&g);
if(a>b){
      t=a;
      a=b;
      b=t;
}

if(a>c){
      t=c;
      c=a;
      a=t;
}

if(a>d){
      t=d;
      d=a;
      a=t;
}

if(a>e){
      t=e;
      e=a;
      a=t;
}

if(a>f){
      t=f;
      f=a;
      a=t;
}

if(a>g){
      t=g;
      g=a;
      a=t;
}

if(b>c){
      t=c;
      c=b;
      b=t;
}

if(b>d){
      t=d;
      d=b;
      b=t;
}

if(b>e){
      t=e;
      e=b;
      b=t;
}


if(b>f){
      t=f;
      f=b;
      b=t;
}

if(b>g){
      t=g;
      g=b;
      b=t;
}

if(c>d){
      t=d;
      d=c;
      c=t;
}

if(c>e){
      t=e;
      e=c;
      c=t;
}

if(c>f){
      t=f;
      f=c;
      c=t;
}

if(c>g){
      t=g;
      g=c;
      c=t;
}

if(d>e){
      t=e;
      e=d;
      d=t;
}

if(d>f){
      t=f;
      f=d;
      d=t;
}

if(d>g){
      t=g;
      g=d;
      d=t;
}

if(e>f){
      t=f;
      f=e;
      e=t;
}

if(e>g){
      t=g;
      g=e;
      e=t;
}

if(f>g){
      t=g;
      g=f;
      f=t;
}


printf("%-5.2f,%5.2f,%5.2f,%5.2f,%5.2f,%5.2f,%5.2f\n",a,b,c,d,e,f,g);
}

利用中间变量t 进行替换
再利用a依次比较大小，然后b，然后c.... 最后确定f与g的大小。
输出

1万 · 2016-4-30 22:15

这个方法没有冒泡法好用吧。

1万 · 2016-4-30 23:09

虽然看起来很奇怪，不过真是个不错的排序方法。

1万 · 2016-4-30 23:11

仔细看看，就是通过if来完成了个冒泡的全部。

只看该作者 · 2016-5-21 12:42

实际上这就是把冒泡排序拆分开了

1万 · 2016-5-22 18:10

有创意，再次让我复习了一下if的用处。

1万 · 2016-5-23 03:40

排序的值要是有100个，你的程序会不会ROM不够？

只看该作者 · 2016-5-23 10:20

戈卫东发表于 2016-5-23 03:40
排序的值要是有100个，你的程序会不会ROM不够？

简单的才能用这种笨方法，复杂的就for循环了。

1万 · 2016-5-23 20:09

这方法误人子弟啊，不建议学，多了怎么弄，三个数据还可以，多了别瞎搞，还是for，各种排序上。

1万 · 2016-5-24 23:08

排序可以用冒泡排序法或快速排序法

1万 · 2016-5-24 23:09

经典排序算法 - 冒泡排序Bubble sort

原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换,

这样一趟过去后,最大或最小的数字被交换到了最后一位,

然后再从头开始进行两两比较交换,直到倒数第二位时结束,其余类似看例子

例子为从小到大排序,

原始待排序数组| 6 | 2 | 4 | 1 | 5 | 9 |

第一趟排序(外循环)

第一次两两比较6 > 2交换(内循环)

交换前状态| 6 | 2 | 4 | 1 | 5 | 9 |

交换后状态| 2 | 6 | 4 | 1 | 5 | 9 |

第二次两两比较,6 > 4交换

交换前状态| 2 | 6 | 4 | 1 | 5 | 9 |

交换后状态| 2 | 4 | 6 | 1 | 5 | 9 |

第三次两两比较,6 > 1交换

交换前状态| 2 | 4 | 6 | 1 | 5 | 9 |

交换后状态| 2 | 4 | 1 | 6 | 5 | 9 |

第四次两两比较,6 > 5交换

交换前状态| 2 | 4 | 1 | 6 | 5 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

第五次两两比较,6 < 9不交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

第二趟排序(外循环)

第一次两两比较2 < 4不交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

第二次两两比较,4 > 1交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |
交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

第三次两两比较,4 < 5不交换

交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |
交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

第四次两两比较,5 < 6不交换

交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

第三趟排序(外循环)

第一次两两比较2 > 1交换

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

第二次两两比较,2 < 4不交换

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

第三次两两比较,4 < 5不交换

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

第四趟排序(外循环)无交换

第五趟排序(外循环)无交换

排序完毕,输出最终结果1 2 4 5 6 9

1万 · 2016-5-24 23:13

static void bubble_sort(int[] unsorted)
      {
         for (int i = 0; i < unsorted.Length; i++)
         {
            for (int j = i; j < unsorted.Length; j++)
            {
                  if (unsorted[i] > unsorted[j])
                  {
                     int temp = unsorted[i];
                     unsorted[i] = unsorted[j];
                     unsorted[j] = temp;
                  }
            }
         }
      }

      static void Main(string[] args)
      {
         int[] x = { 6, 2, 4, 1, 5, 9 };
         bubble_sort(x);
         foreach (var item in x)
         {
            Console.WriteLine(item);
         }
         Console.ReadLine();
      }

1万 · 2016-5-24 23:14

1万 · 2016-5-24 23:15

经典排序算法 - 快速排序Quick sort

原理,通过一趟扫描将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列

举个例子

如无序数组[6 2 4 1 5 9]

a),先把第一项[6]取出来,

用[6]依次与其余项进行比较,

如果比[6]小就放[6]前边,2 4 1 5都比[6]小,所以全部放到[6]前边

如果比[6]大就放[6]后边,9比[6]大,放到[6]后边,//6出列后大喝一声,比我小的站前边,比我大的站后边,行动吧!霸气十足~

一趟排完后变成下边这样:

排序前 6 2 4 1 5 9

排序后 2 4 1 5 6 9

b),对前半拉[2 4 1 5]继续进行快速排序

重复步骤a)后变成下边这样:

排序前 2 4 1 5

排序后 1 2 4 5

前半拉排序完成,总的排序也完成:

排序前:[6 2 4 1 5 9]

排序后:[1 2 4 5 6 9]

排序结束

1万 · 2016-5-24 23:17

复制

static int partition(int[] unsorted, int low, int high)

        {

            int pivot = unsorted[low];

            while (low < high)

            {

                while (low < high && unsorted[high] > pivot) high--;

                unsorted[low] = unsorted[high];

                while (low < high && unsorted[low] <= pivot) low++;

                unsorted[high] = unsorted[low];

            }

            unsorted[low] = pivot;

            return low;

        }



        static void quick_sort(int[] unsorted, int low, int high)

        {

            int loc = 0;

            if (low < high)

            {

                loc = partition(unsorted, low, high);

                quick_sort(unsorted, low, loc - 1);

                quick_sort(unsorted, loc + 1, high);

            }

        }



        static void Main(string[] args)

        {

            int[] x = { 6, 2, 4, 1, 5, 9 };

            quick_sort(x, 0, x.Length - 1);

            foreach (var item in x)

            {

                Console.WriteLine(item + ",");

            }

            Console.ReadLine();

        }

1万 · 2016-5-24 23:17

经典排序算法 - 桶排序Bucket sort

补充说明三点

1,桶排序是稳定的

2,桶排序是常见排序里最快的一种,比快排还要快…大多数情况下

3,桶排序非常快,但是同时也非常耗空间,基本上是最耗空间的一种排序算法

我自己的理解哈,可能与网上说的有一些出入,大体都是同样的原理

无序数组有个要求,就是成员隶属于固定(有限的)的区间,如范围为[0-9](考试分数为1-100等)

例如待排数字[6 2 4 1 5 9]

准备10个空桶,最大数个空桶

[6 2 4 1 5 9] 待排数组

[0 0 0 0 0 0 0 0 0 0] 空桶

[0 1 2 3 4 5 6 7 8 9] 桶编号(实际不存在)

1,顺序从待排数组中取出数字,首先6被取出,然后把6入6号桶,这个过程类似这样:空桶[ 待排数组[ 0 ] ] = 待排数组[ 0 ]

[6 2 4 1 5 9] 待排数组

[0 0 0 0 0 0 6 0 0 0] 空桶

[0 1 2 3 4 5 6 7 8 9] 桶编号(实际不存在)

2,顺序从待排数组中取出下一个数字,此时2被取出,将其放入2号桶,是几就放几号桶

[6 2 4 1 5 9] 待排数组

[0 0 2 0 0 0 6 0 0 0] 空桶

[0 1 2 3 4 5 6 7 8 9] 桶编号(实际不存在)

3,4,5,6省略,过程一样,全部入桶后变成下边这样

[6 2 4 1 5 9] 待排数组

[0 1 2 0 4 5 6 0 0 9] 空桶

[0 1 2 3 4 5 6 7 8 9] 桶编号(实际不存在)

0表示空桶,跳过,顺序取出即可:1 2 4 5 6 9

1万 · 2016-5-24 23:18

复制

/// <summary>

        /// 桶排序

        /// 1),已知其区间,例如[1..10],学生的分数[0...100]等

        /// 2),如果有重复的数字,则需要 List<int>数组,这里举的例子没有重复的数字

        /// </summary>

        /// <param name="unsorted">待排数组</param>

        /// <param name="maxNumber">待排数组中的最大数,如果可以提供的话</param>

        /// <returns></returns>

        static int[] bucket_sort(int[] unsorted, int maxNumber = 99)

        {

            int[] sorted = new int[maxNumber + 1];

            for (int i = 0; i < unsorted.Length; i++)

            {

                sorted[unsorted[i]] = unsorted[i];

            }

            return sorted;

        }



        static void Main(string[] args)

        {

            int[] x = { 99, 65, 24, 47, 50, 88,33, 66, 67, 31, 18 };

            var sorted = bucket_sort(x, 99);

            for (int i = 0; i < sorted.Length; i++)

            {

                if (sorted[i] > 0)

                    Console.WriteLine(sorted[i]);

            }

            Console.ReadLine();

        }

1万 · 2016-5-24 23:20

经典排序算法 – 插入排序Insertion sort
插入排序就是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置，直到全部插入完毕。
插入排序方法分直接插入排序和折半插入排序两种，这里只介绍直接插入排序，折半插入排序留到“查找”内容中进行。
图1演示了对4个元素进行直接插入排序的过程，共需要(a),(b),(c)三次插入。

1万 · 2016-5-24 23:21

复制

/// <summary>

        /// 插入排序

        /// </summary>

        /// <param name="unsorted"></param>

        static void insertion_sort(int[] unsorted)

        {

            for (int i = 1; i < unsorted.Length; i++)

            {

                if (unsorted[i - 1] > unsorted[i])

                {

                    int temp = unsorted[i];

                    int j = i;

                    while (j > 0 && unsorted[j - 1] > temp)

                    {

                        unsorted[j] = unsorted[j - 1];

                        j--;

                    }

                    unsorted[j] = temp;

                }

            }

        }



        static void Main(string[] args)

        {

            int[] x = { 6, 2, 4, 1, 5, 9 };

            insertion_sort(x);

            foreach (var item in x)

            {

                if (item > 0)

                    Console.WriteLine(item + ",");

            }

            Console.ReadLine();

        }

1万 · 2016-5-24 23:22

经典排序算法 - 鸽巢排序Pigeonhole sort

原理类似桶排序,同样需要一个很大的鸽巢[桶排序里管这个叫桶,名字无所谓了]

鸽巢其实就是数组啦,数组的索引位置就表示值,该索引位置的值表示出现次数,如果全部为1次或0次那就是桶排序

例如

var pigeonHole = new int[100];

pigeonHole[0]的值表示0的出现次数...

pigeonHole[1]的值表示1的出现次数...

pigeonHole[2]的值表示2的出现次数...

复制

/// 鸽巢排序

        /// </summary>

        /// <param name="unsorted">待排数组</param>

        /// <param name="maxNumber">待排数组中的最大数,如果可以指定的话</param>

        /// <returns></returns>

        static int[] pogeon_sort(int[] unsorted, int maxNumber = 10)

        {

            int[] pogeonHole = new int[maxNumber + 1];

            foreach (var item in unsorted)

            {

                pogeonHole[item]++;

            }

            return pogeonHole;

            /*

             * pogeonHole[10] = 4; 的含意是

             * 在待排数组中有4个10出现,同理其它

             */

        }



        static void Main(string[] args)

        {

            int[] x = { 99, 65, 24, 47, 47, 50, 99, 88, 66, 33, 66, 67, 31, 18, 24 };

            var sorted = pogeon_sort(x, 99);

            for (int i = 0; i < sorted.Length; i++)

            {

                for (int j = 0; j < sorted[i]; j++)

                {

                    Console.WriteLine(i);

                }

            }

            Console.ReadLine();

        }

if语句输出 由大到小的数字

技术高手奖章

湍急之河流

精华达人奖章

常驻人口

技术奇才奖章

奔腾之江水

七世轮回

精英会员奖章

技术新星奖章

社区建设奖章

经常做客

if语句输出由大到小的数字