java常用简单算法

1. 选择排序：之所以用一个数来记录最小值的位置，在最后来进行数据交换，是因为每一次数组交换数据都是在Heap内存中进行的，很消耗内存。
原理：第n趟以n-1为不动点，与后面所有数据进行比较，如何发现有一个数据比n-1个数据小，就记录它的索引，在n趟比较结束后，再交换数据

public static void selectSort(int[] arr)
    {
        //arr==null,arr.length==0，不同
        if (arr==null||arr.length==0) {
            return;
        }
        for(int i=0;i<arr.length-1;i++)
        {
            int index=i;
            for(int j=i+1;j<arr.length;j++)
            {
                if (arr[index]>arr[j]) 
                {
                    index=j;
                }
            }
            if (index!=i)
            {
                int temp=arr[i];
                arr[i]=arr[index];
                arr[index]=temp;
            }
        }   
    }

2. 冒泡排序：它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

public static void bubbleSort(int[] arr)
    {
        for(int i=0;i<arr.length;i++)
        {
            for(int j=0;j<arr.length-i-1;j++)
            {
                if (arr[j]>arr[j+1]) {
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }

3. 插入排序：直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的纪录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的纪录插入完为止，得到一个新的有序序列。

public static void insertSort(int[] arr)
    {
        if (arr==null||arr.length<2)
         {
             return;    
         }
        int temp=0;  
        for(int i=1;i<arr.length;i++)
        {  
              int j=i-1;  
              temp=arr[i];  
              for(;j>=0&&temp<arr[j];j--)
              {  
                  //将大于temp的值整体后移一个单位  
                  arr[j+1]=arr[j];                       
              }  
              arr[j+1]=temp;  
        }  
    }

4. 快速排序该方法的基本思想是：
1．先从数列中取出一个数作为基准数。
2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3．再对左右区间重复第二步，直到各区间只有一个数。

public static void quickSort(int[] arr, int low, int hight) {

        if (low < hight) {

            int i = low;
            int j = hight;
            int x = arr[i];

            while (i < j) {

                while (i < j && arr[j] > x)
                    j--;
                if (i < j)
                    arr[i++] = arr[j];

                while (i < j && arr[i] < x)
                    i++;
                if (i < j)
                    arr[j++] = arr[i];
            }

            arr[i] = x;
            quickSort(arr, low, i - 1);
            quickSort(arr, i + 1, hight);
        }
    }

5. 二分查找：

public static void selectSearch(int[] find,int key) 
    {
        int low=0;
        int hight=find.length-1;
        int mid=(hight+low)/2;
        while(low<hight)
        {
            mid=(hight+low)/2;
            if (find[mid]==key) 
            {
                System.out.println("找到了"+mid);
                return;
            }

            if (find[mid]>key)
            {
                hight=mid-1;
            }else {
                low=mid+1;
            }       
        }
    }