算法

package com.learning.sort;

import java.awt.List;
import java.util.ArrayList;
import java.util.Collections;

public class MergeSort implements Comparable<MergeSort>{
    private int x;
    private int y;
    public MergeSort(int x,int y){
        this.x = x;
        this.y = y;
    }
    public int getX(){
        return this.x;
    }
    public int getY(){
        return this.y;
    }
    private void mergeSort(int[] data,int first,int last,int[] temp){
        if(first<last){
            int mid = (first+last)/2;
            mergeSort(data, first, mid,temp);//爲什麼這樣就可以變爲有序啊?
            mergeSort(data, mid+1, last,temp);
            mergeArray(data, first, last, mid, temp);
        }
    }
    private void mergeArray(int[] data,int first,int last,int mid,int[] temp){
        int i = first;int j = mid +1;
        int n = last; int k = 0;int m = mid;
        while(i<=m&&j<=n){
            if(data[i]<data[j])
                temp[k++] = data[i++];
            else
                temp[k++] = data[j++];
        }
        while(i<=m)
            temp[k++] = data[i++];
        while(j<=n)
            temp[k++] = data[j++];
        for(i = 0;i<k;i++){
            data[first+i] = temp[i];
        }
    }

    public boolean MergeSortS(int[] data,int n){
        int[] temp = new int[n]; 
        mergeSort(data, 0, n-1,temp);
        temp = null;
        return true;
    }
    public void quickSort(int[] data,int start,int end){
        if(start<end){
            int i = start;
            int j = end;
            int privotKey = data[i];//通常從第一個數開始比較
            while(i<j){
                while(i<j&&data[j]>privotKey)j--;
                if(i<j)data[i++] = data[j];
                while(i<j&&data[i]<privotKey)i++;
                if(i<j)data[j--]=data[i];
            }
            data[i]=privotKey;//因爲i=j
            quickSort(data,start,i-1);
            quickSort(data, i+1, end);
        }
    }
    //二分搜索法非遞歸
    public int dichotomiaSearch(int[] data,int fromIndex,int endIndex,int param){
        if(endIndex>fromIndex){
            int low = fromIndex;int high = endIndex;
            while(low<high){
                int middle = (low+high)>>>1;
                if(data[middle]==param)
                    return middle;
                else if(data[middle]>param)
                    high = middle-1;
                else
                    low = middle+1;
            }
        }
        return -(fromIndex+1);
    }
    //二分搜索法 遞歸查找
    public int dichotomiaSearch1(int[] data,int fromIndex,int endIndex,int param){
        if(endIndex>fromIndex){
            int low = fromIndex;int high = endIndex;
                int middle = (low+high)>>>1;
                if(data[middle]==param)
                    return middle;
                else if(data[middle]>param)
                    return dichotomiaSearch1(data,fromIndex,middle-1,param);
                else
                    return dichotomiaSearch1(data,middle+1,endIndex,param);
        }
        return -(fromIndex+1);
    }
    //順序查找
    public int generalSearch(int[] data,int n ,int key){
        int value = data[0];
        data[0] = key;
        int i = n;
        while(data[i] != key)
            i--;
        if(i ==0)
            if(value==key)
                return 0;
        data[0] = value;
        return i;
    }
    //選擇排序
    public void sort(int[] data){
      for(int i = 0 ; i < data.length-1 ; i++){
          for(int j = i+1 ; j < data.length ; j++){
              int temp ;
              if(data[i] > data[j]){
                  temp = data[j];
                  data[j] = data[i];
                  data[i] = temp;
              }
          }
       }
    }
    //冒泡排序
    public void bubbingSort(int[] data,int start,int end){
        int length = data.length;
        int temp=0;
        for(int i =0;i<length;i++){
            for(int j= 0;j<length-i-1;j++){
                if(data[j]>data[j+1]){
                    temp = data[j+1];
                    data[j+1] = data[j];
                    data[j] = temp;
                }
            }
        }
    }
    public void sort2(int[] data,int param){
        int length = data.length;
        for(int i=length-1;i>=0;i--){
            if(param>=data[i]){
                data[i+1] = param;
                return;
            }
            else
                data[i+1] = data[i];
        }
        return;
    }
    //直接插入排序
    public void insertSort(int[] data){
        int length = data.length;
        for(int i = 2;i<length;i++){//假定1自成有序
            if(data[i]<data[i-1]){//說明data[i]應該被插入到已經排好序的數組中.否則放在原來位置
                data[0] = data[i];
                int j = i-1;
                while(data[j]>data[0]){data[j+1] = data[j];j--;}
                data[j+1] = data[0];
            }
        }
    }
    //希爾排序(分組插入排序)
    public void groupInsertSort(int[] data){
        int length = data.length;
        for(int gap = length/2;gap>0;gap/=2){
            for(int i = 0;i<gap;i++){
                for(int j = i+gap;j<length;j+=gap){
                    if(data[j]>data[j-gap]){
                        int temp = data[j];
                        int k = j-gap;
                        while(k>=0&&data[k]<temp){
                            data[k+gap] = data[k];k-=gap;
                        }
                        data[k+gap] = temp;
                    }
                }
            }
        }
    }
    //列表排序
    private static void listSort(){
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(3);
        list.add(2);
        list.add(1);
        list.add(9);
        list.add(12);
        list.add(32);
        list.add(1321);
        list.add(423);
        Collections.sort(list);
        for( int x : list){
            System.out.print(x+",");
        }
        ArrayList<MergeSort> mList = new ArrayList<MergeSort>();
        MergeSort mSort1 = new MergeSort(5, 4);
        MergeSort mSort2 = new MergeSort(2, 4);
        MergeSort mSort3 = new MergeSort(1, 24);
        MergeSort mSort4 = new MergeSort(32, 14);
        MergeSort mSort5 = new MergeSort(12, 44);
        MergeSort mSort6 = new MergeSort(32, 14);
        MergeSort mSort7 = new MergeSort(13, 4);
        MergeSort mSort8 = new MergeSort(2, 14);
        MergeSort mSort9 = new MergeSort(1, 34);
        MergeSort mSort10 = new MergeSort(32,21);
        MergeSort mSort11 = new MergeSort(1, 2);
        MergeSort mSort12 = new MergeSort(1, 4);
        MergeSort mSort13 = new MergeSort(3, 1);
        mList.add(mSort1);
        mList.add(mSort2);
        mList.add(mSort3);
        mList.add(mSort4);
        mList.add(mSort5);
        mList.add(mSort6);
        mList.add(mSort7);
        mList.add(mSort8);
        mList.add(mSort9);
        mList.add(mSort10);
        mList.add(mSort11);
        mList.add(mSort12);
        mList.add(mSort13);
        Collections.sort(mList);
        for(int m =0;m<mList.size();m++){
            System.out.println("排序"+m+":"+mList.get(m).getX()+"|"+mList.get(m).getY());
        }
    }
    public static void main(String[] args) {
        /*int n = 50000;
        int[] data = new int[n];
        int[] data1 = new int[n];
        int[] data2 = new int[n];
        int[] data3 = new int[n];
        int[] data4 = new int[n];
        int[] data5 = new int[n];
        int[] data6 = new int[n];
        MergeSort mergeSort = new MergeSort();
        for(int i=0;i<n;i++){
            data[i] = (int)((Math.random()*1000000));
        }
        double start = System.currentTimeMillis();
        mergeSort.MergeSortS(data,n);
        double end = System.currentTimeMillis();
        System.out.println("歸併排序耗時:"+(end-start));
        for(int i=0;i<n;i++){
            data1[i] = (int)((Math.random()*10000));
        }
        double start1 = System.currentTimeMillis();
        mergeSort.quickSort(data1,0,data1.length-1);
        double end1 = System.currentTimeMillis();
        System.out.println("快速排序耗時:"+(end1-start1));
        //for(int l:data)System.out.print(l+",");
        //排序之後使用二分查找(非遞歸)
        double start2 = System.nanoTime();
        System.out.println(mergeSort.dichotomiaSearch(data1, 0, data1.length-1, 2131));
        double end2 = System.nanoTime();
        System.out.println("非遞歸二分查找耗時:"+(end2-start2));

        //排序之後使用二分查找(遞歸)
        double start4 = System.nanoTime();
        System.out.println(mergeSort.dichotomiaSearch1(data1, 0, data1.length-1, 2131));
        double end4 = System.nanoTime();
        System.out.println("遞歸二分查找耗時:"+(end4-start4));

        //排序之後使用順序查找
        double start3 = System.nanoTime();
        System.out.println(mergeSort.generalSearch(data1, data1.length-1, 2131));
        double end3 = System.nanoTime();
        System.out.println("順序查找耗時:"+(end3-start3));
        for(int i=0;i<n;i++){
            data2[i] = (int)((Math.random()*1000000));
        }
        //選擇排序
        double start5 = System.currentTimeMillis();
        mergeSort.sort(data2);
        double end5 = System.currentTimeMillis();
        System.out.println("選擇排序耗時:"+(end5-start5));
        for(int i=0;i<n;i++){
            data3[i] = (int)((Math.random()*1000000));
        }
        double start6 = System.currentTimeMillis();
        mergeSort.bubbingSort(data3, 0, data1.length);
        double end6 = System.currentTimeMillis();
        System.out.println("冒泡排序耗時:"+(end6-start6));
        for(int i=0;i<n;i++){
            data4[i] = (int)((Math.random()*1000000));
        }
        double start7 = System.currentTimeMillis();
        mergeSort.bubbingSort(data4, 0, data1.length);
        double end7 = System.currentTimeMillis();
        System.out.println("直接插入排序耗時:"+(end7-start7));
        for(int i=0;i<n;i++){
            data5[i] = (int)((Math.random()*1000000));
        }
        double start8 = System.currentTimeMillis();
        mergeSort.groupInsertSort(data5);
        double end8 = System.currentTimeMillis();
        System.out.println("分組插入排序耗時:"+(end8-start8));
        for(int m:data5) System.out.print(m+",");
        */
        //使用Collections類得排序方法進行鏈表排序
        listSort();
    /*  （1） 排序算法
        快速排序      
        合併排序
        堆排序
        選擇排序
        基數排序
        冒泡排序
        插入排序
        希爾排序
        鏈表排序

        （2） 數據結構
        線性隊列
        線性堆棧
        單向鏈表
        雙向鏈表
        循環單向鏈表
        排序二叉樹（插入，刪除上、中、下、保存和加載）
        哈希表
        哈希二叉樹

        （3）圖
        圖結構
        圖創建
        圖的添加、刪除
        圖的保存
        prim算法（上、中、下）
        哈夫曼樹（上、下）    
        克魯斯卡爾算法（上、中、下）

        （4）常用算法
        查找
        內存分配
        字符串查找（上、中、下）
        通用數據結構
        通用算法
        循環和遞歸
        遞歸和堆棧
        內存中的數據
        A*算法
        可變參數
        函數堆棧
        遞歸尋路
        廣度遍歷、深度遍歷
        排序二叉樹線索化

        （5）趣味算法題目
        鏈表逆轉
        大數計算
        n！末位0個數計算
        洗牌算法
        “數星星”
        八皇后
        數據選擇
        單詞統計
        爬樓梯
        回數
        鏈表重合
        尋找丟失的數
        最大公約數、最小公倍數
        挑選最大的n個數*/

    }
    @Override
    public int compareTo(MergeSort o) {
        if(o.x>o.y) return 1;
        if(o.x == o.y) return 0;
        else return -1;
    }
}