如果要对四个变量a,b,c,d（都已经有值了）用冒泡法排序  该如何弄

1.       int main()
   
2.         {
   
3.                 int a=1;
   
4.                 int b=5;
   
5.                 int c=3;
   
6.                 int d=4;
   
7.                 int[] array=Sort(a,b,c,d);
   
8. 
   
9.                 for(int i=0;i<array.length;i++)
   
10.                 {
    
11.                         System.out.println(array);
    
12.                 }
    
13.                 return 0;
    
14.         }
    
15. //不知道C里有没有可变参数这个说法，OC里有，不行就弄个OC的项目试试
    
16.            int[] Sort(int...arr)
    
17.         {
    
18.                
    
19.            for(int i=0;i<arr.length-1;i++)
    
20.                    {
    
21.                            for(int j=i;j<arr.length-i-1;j++)
    
22.                            {
    
23.                                    if(arr[j+1]>arr[j])
    
24.                                    {
    
25.                                            int temp=arr[j];
    
26.                                            arr[j]=arr[j+1];
    
27.                                            arr[j+1]=temp;
    
28.                                    }
    
29.                            }
    
30.                    }
    
31.                    return arr;
    
32.         }

复制代码

1. #include <stdio.h>
   
2. 
   
3. // 定义一个主函数，作为程序的入口
   
4. int main()
   
5. {
   
6.     // 定义两个变量用于for循环条件变量
   
7.     int i,j;
   
8.    
   
9.     // 定义四个变量用来存放abcd
   
10.     int a = 10;
    
11.     int b = 15;
    
12.     int c = 2;
    
13.     int d = 9;
    
14.    
    
15.     // 定义一个数组x用来存放abcd
    
16.     int x[4] = {a,b,c,d};
    
17.    
    
18.     // 定义temp用于冒泡排序交换变量值
    
19.     int temp;
    
20.    
    
21.     // 冒泡排序  将a,b,c,d降序排序，i表示排序的趟数，j表示每趟排序的比较次数
    
22.     for (i = 0; i<3; i++)
    
23.     {
    
24.         for(j = 0;j<3-i;j++)
    
25.         {
    
26.             if (x[j] < x[j+1])
    
27.             {
    
28.                 // 当前一个元素小于后一个元素时，交换它们的位置
    
29.                 temp = x[j];
    
30.                 x[j] = x[j+1];
    
31.                 x[j+1] = temp;
    
32.             }
    
33. 
    
34.         }
    
35.     }
    
36.    
    
37.     // 定义一个数组y用来存放abcd标志
    
38.     char y[4];
    
39.    
    
40.     // 将数组x与数组y的变量和标志一一对应
    
41.     for (i = 0; i<4; i++)
    
42.     {
    
43.         // 确定排序后a的位置
    
44.         if(x[i] == a && y[0] != 'a' && y[1] != 'a' && y[2] != 'a' && y[3] != 'a')
    
45.         {
    
46.             y[i] = 'a';
    
47.         }
    
48.         // 确定排序后b的位置
    
49.         else if(x[i] == b && y[0] != 'b' && y[1] != 'b' && y[2] != 'b' && y[3] != 'b')
    
50.         {
    
51.             y[i] = 'b';
    
52.         }
    
53.         // 确定排序后c的位置
    
54.         else if(x[i] == c && y[0] != 'c' && y[1] != 'c' && y[2] != 'c' && y[3] != 'c')
    
55.         {
    
56.             y[i] = 'c';
    
57.         }
    
58.         // 确定排序后d的位置
    
59.         else
    
60.         {
    
61.             y[i] = 'd';
    
62.         }
    
63.     }
    
64.    
    
65.     // 降序打印输出每个字母出现的次数
    
66.     for (i = 0; i<4; i++)
    
67.     printf("%c=%d\n",y[i],x[i]);
    
68.    
    
69.     return 0;
    
70. }

复制代码

你看下，我做的是降序排序abcd的值，升序排序你对比着写，只要理解了冒泡排序过程，写代码并不难。

1. struct paixu
   
2. {
   
3.         char m;
   
4.         int n;
   
5. }a[4];
   
6. #include <stdio.h>
   
7. void main()
   
8. {
   
9. 
   
10.         a[0].n=3;a[1].n=8;a[2].n=5;a[3].n=2;
    
11.             a[0].m='a';a[1].m='b';a[2].m='c';a[3].m='d';
    
12. 
    
13.         int i,j,flag,temp;
    
14.                 char temp1;
    
15.         for(i=3;i>0;--i)
    
16.         {
    
17.                 flag=0;//变量flag用来标记本趟排序是否发生了变化
    
18.                 for(j=1;j<=i;++j)
    
19.                         if(a[j-1].n>a[j].n)
    
20.                         {
    
21.                                 temp=a[j].n;
    
22.                                 a[j].n=a[j-1].n;
    
23.                                 a[j-1].n=temp;
    
24.                                                                 temp1=a[j].m;
    
25.                                 a[j].m=a[j-1].m;
    
26.                                 a[j-1].m=temp1;
    
27.                                 flag=1;//如果没发生变换flag值为0，发生交换则改为1
    
28.                         }
    
29.                         if(flag==0)  //一趟排序过程中没有发生元素交换，则证明序列有序，排序结束
    
30.                                 break;
    
31.         }
    
32.         printf("排序后的结果：\n");
    
33.         for(i=0;i<4;++i)
    
34.         printf("%c %d\n",a[i].m,a[i].n);
    
35.         printf("\n");
    
36. }

复制代码