温习下几种排序

package collecttionDemo;

import java.util.Arrays;

public class SortDemo {
 public static void main(String[] args) {
  int[] array={8,2,3,7,1} ;
//  int[] arraySSort=sSort(array);
  int[] arrayISort=iSort(array);
//  int[] arrayMSort=mSort(array);
//  System.out.println(Arrays.toString(arraySSort));
//  System.out.println(Arrays.toString(arrayMSort));
  System.out.println(Arrays.toString(arrayISort));
 }
 /*选择排序:
  a 将数组中的每个元素,与第一个元素比较如果这个元素小于第一个元素, 就将这个两个元素交换.
     b 每轮使用a的规则, 可以选择出一个最小元素放到第一个位置.
     c 经过n-1轮比较完成排序
    简单说: 每轮选择最小的放到前面.
    优点：移动数据的次数已知（n-1次）；
    缺点：比较次数多。*/
 public static int[] sSort(int[] array){
  int temp=0;
  for(int i=0;i<array.length;i++){
   int j=i+1;
   for(;j<array.length;j++){
    if(array[i]>array[j]){
     temp=array[i];
     array[i]=array[j];
     array[j]=temp;
    }
   }
  }
  return array;
 }
 /*冒泡排序
    原理:
 a 逐一比较数组中相邻的两个元素, 如果后面 的数字小于前面的数字, 就交换先后元素.
 b 经过一个轮次的比较, 一定有一个最大的排在最后的位置.
 c 每次比较剩下的元素, 经过n-1次比较, 可以实现排序
 简单说: 比较相邻元素,大的向后交换
  优点：稳定；
            缺点：慢，每次只能移动相邻两个数据。
 */
 public static int[] mSort(int[] array){
  int temp=0;
  int length=array.length;
  for(int i=0;i<length;i++){
   for(int j=0;j<length-1;j++){
    if(array[j]>array[j+1]){
     temp=array[j+1];
     array[j+1]=array[j];
     array[j]=temp;
    }
   }
   i=0;
   length=length-1;
  }
  return array;
 }
 /*插入排序
   原理: a 将数组分为两部分, 将后部分的第一张逐一与前部分每一张比较, 如果当前元素小, 就一点被比较元素.
        b 找到合理位置插入.
   原理说明: 将后组的每一个元素插入到前一组合适的位子上
   优点：稳定，快；
     缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是当数据总量庞大的时候，但用链表可以解决这个问题。
   */
 public static int[] iSort(int[] array){
  int temp=0;
  int length=array.length;
  int j;
  for(int i=1;i<length;i++){
   temp=array[i];//待插入的数据
   for(j=i-1;j>=0;j--){
    if(temp<array[j]){
     array[j+1]=array[j];
     array[j]=temp;
    }
   }
  }
  return array;
 }
}

以上是重温的几种排序，这两天看web方面的东西却发现关于corejava的东西很多都忘记了，这几天恶补中！！！