排序算法----插入排序、歸併排序

插入排序

原理：將待排序的元素按照其大小插入到已經排序的數據中的適當位置，直到所有插入完畢

/**
 * 插入排序 將待排序的元素按照其大小插入到已經排序的數據中的適當位置，直到所有插入完畢
 * 
 * @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());
        }
}