算法

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;
    }
}