排序算法----插入排序、归并排序

插入排序

原理：将待排序的元素按照其大小插入到已经排序的数据中的适当位置，直到全部插入完毕

/**
 * 插入排序 将待排序的元素按照其大小插入到已经排序的数据中的适当位置，直到全部插入完毕
 * 
 * @author Administrator
 *
 */
public class InsertSort {
        public static void main(String[] args) {
                int number[] = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
                // 由小到大 从第二个元素开始与前面的元素比较大小
                    for (int i = 1; i < number.length; i++) {
                        compare(number, i);
                    }
                p(number);
        }
        private static void compare(int[] number, int index) {
                // 当前元素位置的前一个位置开始与index位置比较,
                // 如果number[index]<number[index-1]交换位置
                // 并且index值应该变更为index-1
                for (int i = index - 1; i >= 0; i--) {
                        if (number[index] < number[i]) {
                                int temp = number[i];
                                number[i] = number[index];
                                number[index] = temp;
                                index = i;
                        }
                }
        }
        private static void p(int num[]) {
                StringBuilder sb = new StringBuilder(num.length);
                for (int i = 0; i < num.length; i++) {
                sb.append(num[i]);
                sb.append(" ");
                }
                System.out.println(sb.toString());
        }
}

归并排序

/**
 * 归并排序
 * 指的是将两个已经排序的序列合并成一个序列的操作。归并排序算法依赖归并操作。
 * 递归法
 *  原理如下（假设序列共有n个元素）：
 *  1.将序列每相邻两个数字进行归并操作，形成floor(n/2)个序列，排序后每个序列包含两个元素
 *  2.将上述序列再次归并，形成floor(n/4)个序列，每个序列包含四个元素
 *  3.重复步骤2，直到所有元素排序完毕
 * @author Administrator
 *
 */
public class MegerSort {
            //由小到大排序
        public static void main(String[] args) {
          int number[] = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
          int temp[] = new int[number.length];
           sort(number,temp,0,number.length-1);
           p(number);
        }
        private static void sort(int[] number,int[] temp,int start,int end) {
                if(start>=end){
                  return;
                }
                //分组number[start]到number[end]之间元素个数
                int len = end-start+1;
                //如果是数组长度是奇数分两部分 前一部分元素数量比后一部分少一个  
                //如果是数组长度是偶数分两部分 前一部分元素数量和后一部分元素数量相同
                int mid  = (len%2 == 1 ? (len-1)/2:len/2)+start  ;
                //第一部分数组元素范围
                int start1 = start,end1=mid-1; 
                //第二部分数组元素范围
                int start2 = mid,end2 = end;
                //递归继续分组
                sort(number,temp,start1,end1);
                sort(number,temp,start2,end2);
                //分组到最后开始进行合并
                int k = start;
                 //由小到大排序 两组之间进行合并 比较数值大小确定合并后的元素位置  依次比较
                while (start1 <= end1 && start2 <= end2){
                    //从两部分的开头互相比较大小,找出小的放到临时数组中
                  temp[k++] = number[start1] < number[start2] ? number[start1++] : number[start2++];
                }
                //第一部分剩余的归并
                while (start1 <= end1){
                    temp[k++] = number[start1++];
                }
                //第二部分剩余的归并
                while (start2 <= end2){
                    temp[k++] = number[start2++];
                }
                //归并好的元素拷到原来的数组
                for (int i = start; i <= end; i++){
                   number[i] = temp[i];
                }
        }
        private static void p(int num[]) {
            StringBuilder sb = new StringBuilder(num.length);
                for (int i = 0; i < num.length; i++) {
                    sb.append(num[i]);
                    sb.append(" ");
                }
            System.out.println(sb.toString());
        }
}