/*
需求分析：选择排序图示：
0-1 0-2 0-3 0-4 0-5
1-2 2-3 3-4 4-5
2-3 3-4 4-5
3-4 4-5
4-5
通过分析 可以看出是个倒三角形，我们可以用两个for循环嵌套的模式来打印出来

相比较的都是角标位。


*/
class  XZDemo
{        
        public static void paiqian(int[] arr)
                {
                        for(int x=0;x<arr.length;x++)
                        {
                                if(x!=arr.length-1)
                                System.out.print(arr[x]+",");
                                else
                                System.out.println(arr[x]);
                        }
               
                }
        public static void main(String[] args)
                        {
                                int[] arr={5,6,9,12,55,78,43};
               
                //System.out.println("qian=");
                                paiqian(arr);
                                pai(arr);
                                paiqian(arr);
                        }
public static void pai(int[] arr)
        {
        for(int x=0;x<arr.length-1;x++)
                {
                for(int y=x+1;y<arr.length;y++)
                   {
                        if(arr[x]>arr[y])
                                {
                                int temp=arr[x];
                                arr[x]=arr[y];
                                arr[y]=temp;
                                }
               
                        }
                 }
         }
}
这个可以 为什么？

/*0-1 1-2 2-3 3-4 4-5 每增加一个 减少一个 y的值在减少
0-1 1-2 2-3 3-4
0-1 1-2 2-3
0-1 1-2
0-1
先初始化的是最后的一个角标


*/


class MpDemo
{
        //定义一个功能，为了遍历数组中的元素。
        public static void paiqian(int[] arr)
                {
                        for(int x=0;x<arr.length;x++)
                        {
                                if(x!=arr.length-1)
                                System.out.print(arr[x]+",");
                                else
                                System.out.println(arr[x]);
                        }
               
                }

        public static void main(String[] args)
        {
                int[] arr={35,23,43,54,65,56};
                        
                        paiqian(arr);
                                maopao(arr);
                                System.out.println("paihou=");
                                paiqian(arr);
        }
         public static void maopao(int[] arr)
                        {
                                for(int x=0;x<arr.length-1;x++ )
                                        {
                                                for(int y=0;y>arr.length-1-x;y++)//为什么减1 为了避免越界 -x是让逐轮比较元素递减。
                                                        {
                                                                if(arr[y]>arr[y+1])
                                                                        {
                                                                                int temp = arr[y];
                                                                                arr[y]=arr[y+1];
                                                                                arr[y+1]=temp;//选择和冒泡 区别在于 什么和什么相比较。
                        
                                                                        }
                                                               
                                                        }
                                        }
                        }
}
这个 可以又为什么啊？
求正解！！！求分析 ，求分配图！求详细说明 两个一个可以 另一个不可以为什么？

第一个是：选择排序。
    原理是：从数组中的第一个元素开始一次和后面的每一个元素进行比较。然后第二个元素依次和后面的比较。。以此类推
第二个是：冒泡排序。
    原来死：数组中的元素，从第一个开始，相邻两个进行比较：第一个和第二个比较，取较大值或较小值。然后第二个再和第三个比较，第三个再和第四个比较。以此类推。。到最后末尾的那个元素就是最大值或最小值了。
                第二轮比较就不用最后一个元素参与了。按照前面的方法再次比较。 倒数第二个元素就是排序在第二的了。

/* 需求分析：选择排序图示： 0-1 0-2 0-3 0-4 0-5 1-2 2-3 3-4 4-5 2-3 3-4 4-5 3-4 4-5 4-5 通过分析 可以看出是个倒三角形，我们可以用两个for循环嵌套的模式来打印出来 相比较的都是角标位。 */ class  XZDemo {                 public static void paiqian(int[] arr)   //该方法是顺序打印数组的全部元素                 {                         for(int x=0;x<arr.length;x++)                         {                                 if(x!=arr.length-1)     //判断只要不是最后一个元素，则在打印后加一个“，”；否则打印元素且换行                                 System.out.print(arr[x]+",");                                 else                                 System.out.println(arr[x]);                         }                                 }         public static void main(String[] args)   //main方法                         {                                 int[] arr={5,6,9,12,55,78,43};                                 //System.out.println("qian=");                                 paiqian(arr);    //输出排序前的数组                                 pai(arr);        //对数组进行排序                                 paiqian(arr); //输出排序后的数组                         } public static void pai(int[] arr)    //这是选择排序的方法         {         for(int x=0;x<arr.length-1;x++)   //外循环，保证数组中的每一个元素都可以进入内循环与其他元素比较                 {                 for(int y=x+1;y<arr.length;y++)  //内循环，将起始元素与其后面的每一个元素比较，不比较该元素前面的                    {                         if(arr[x]>arr[y])    //如果arr[x]的值大于所比较元素的值，则交换位置                                 {                                 int temp=arr[x];                                 arr[x]=arr[y];                                 arr[y]=temp;                                 }                                         }                  }          } } 这个可以 为什么？ 具体解释见注释 /*0-1 1-2 2-3 3-4 4-5 每增加一个 减少一个 y的值在减少 0-1 1-2 2-3 3-4 0-1 1-2 2-3 0-1 1-2 0-1 先初始化的是最后的一个角标 */ class MpDemo {         //定义一个功能，为了遍历数组中的元素。         public static void paiqian(int[] arr)                 {                         for(int x=0;x<arr.length;x++)                         {                                 if(x!=arr.length-1)                                 System.out.print(arr[x]+",");                                 else                                 System.out.println(arr[x]);                         }                                 }         public static void main(String[] args)         {                 int[] arr={35,23,43,54,65,56};                                                  paiqian(arr);                                       maopao(arr);                                 System.out.println("paihou=");                                 paiqian(arr);         }          public static void maopao(int[] arr)   //冒泡排序方法                         {                                 for(int x=0;x<arr.length-1;x++ )   //外循环，保证每一个元素都参与比较                                         {                                                 for(int y=0;y>arr.length-1-x;y++)//为什么减1 为了避免越界 -x是让逐轮比较元素递减。                                                         {                                                                 if(arr[y]>arr[y+1])  //如果前面的元素大于后面的元素，则交换位置                                                                         {                                                                                 int temp = arr[y];                                                                                 arr[y]=arr[y+1];                                                                                 arr[y+1]=temp;//选择和冒泡 区别在于 什么和什么相比较。                                                                                                  }                                                                                                                         }                                         }                         } } 这个 可以又为什么啊？   具体解释见注释！ 求正解！！！求分析 ，求分配图！求详细说明 两个一个可以 另一个不可以为什么？

就拿楼主的数组当例子，分别分析选择排序和冒泡排序的具体排序过程。
5,6,9,12,55,78,43
选择排序：原则，拿出一个元素，与后面所有的元素逐个对比，其中小的放在该元素位置。
1. 5 6 9 12 55 78 43--》5会依次和后面的元素对比，都比过之后，没有比5小的，所以排序未变。
2. 5 6 9 12 55 78 43--》接着，6依次和后面的元素对比，都比过之后，没有比6小的，所以排序未变。
3,4两步和1,2一样，9和12都是依次与后面的元素比较，排序结果仍未变。
5. 5 6 9 12 55 78 43--》 55与78比较，位置不变，55与43比较，由于55较小，交换位置。
6. 5 6 9 12 43 78 55--》 78与55比较，55较小，交换位置，所以最终排序结果完成。

冒泡排序：原则，前一个和后一个比较，其中小的放在前面，依次向后比较。
1. 5 6 9 12 55 78 43--》 首先，5会和6比较，然后6和9比较，以此类推，直到78和43比较，交换位置。
2. 5 6 9 12 55 43 78 --》继续依据原则比较，这次从6开始，到了55和43比较，交换位置。
3. 5 6 9 12 43 55 78 --》 继续依据原则比较，这次从9开始，无变化。
随后还会比较3趟，但是数组以有序，所以没变化。但是程序还是要走一遍。

这就是选择排序和冒泡排序的实际过程。
希望有帮到你~~