数组的常用算法

package com.bxh.array;

public class ArrayTest {

    private static int max(int m,int n) {
        return m>n?m:n;
    }
    private static int min(int m, int n) {
        return m>n?n:m;
    }
    //递归查找数组中最大的数
    private static int findMax(int[] num,int begin) {
        // TODO Auto-generated method stub
        int n=num.length;
        int len=n-begin;
        if(len==1){
            return num[begin];
        }else{
            return max(num[begin],findMax(num,begin+1));
        }
    }
    //直接查找法：求数组中一个数字减去它右边子数组中的一个数字中最大的差值
    private static int getmax(int[] a) {
        // TODO Auto-generated method stub
        int n=a.length;
        if(a==null || n<=1){
            return Integer.MIN_VALUE;
        }
        int max=Integer.MIN_VALUE;
        
        for (int i = 0; i < n-1; i++) {
            for(int j=i+1;j<n;j++){
                if(a[i]-a[j]>max){
                    max=a[i]-a[j];
                }
            }
        }
        return max;
    }
    //动态规划实现差值最大方法
    private static int getMax1(int[] a) {
        // TODO Auto-generated method stub

        int len=a.length;
        int[] diff=new int[len];
        int[] max=new int[len];
        if(a==null || len<=1){
            return Integer.MIN_VALUE;
        }
        diff[0]=Integer.MIN_VALUE;
        max[0]=a[0];
        for(int i=1;i<len;i++){
            diff[i]=max(diff[i-1],max[i-1]-a[i]);
            max[i]=max(max[i-1],a[i]);
        }
        return diff[len-1];
        
    }
    //对数组的两个子有序段进行合并
    private static void sort1(int[] a, int mid) {
        int len=a.length;
        for (int i = 0; i < mid; i++) {
            if(a[mid]<a[i]){
                swap(a,i,mid);
                for(int j=mid;j<len-1;j++){
                    if(a[j+1]<a[j]){
                        swap(a,i,i+1);
                    }
                }
            }
        }
    }
    private static void sort(int[] a, int mid) {
        // TODO Auto-generated method stub
        int tmp;
        for (int i = 0; i < mid; i++) {
            if(a[mid]<a[i]){
                swap(a,i,mid);
                findRightForMid(a,mid);
            }
        }
    }
    private static void findRightForMid(int[] a, int mid) {
        int len=a.length;
        for(int i=mid;i<len-1;i++){
            if(a[i+1]<a[i]){
                swap(a,i,i+1);
            }
        }
    }
    //交换两个函数
    private static void swap(int[] a, int i, int j) {
        // TODO Auto-generated method stub
        int tmp;
        tmp=a[i];
        a[i]=a[j];
        a[j]=tmp;
    }
    //求数组中两个元素的最小距离
    private static int minDistance(int[] a, int m, int n) {
        // TODO Auto-generated method stub
        if(a==null){
            return Integer.MIN_VALUE;
        }
        int len=a.length;
        int m_index=-1;
        int n_index=-1;
        int min_dist=Integer.MIN_VALUE+1;
        
        for(int i=0;i<len;i++){
            if(a[i]==m){
                m_index=i;
            }
            if(n_index>=0){
                min_dist=min(Math.abs(n_index-m_index),Math.abs(min_dist));
            }
            if(a[i]==n){
                n_index=i;
            }
            if(m_index>=0){
                min_dist=min(Math.abs(n_index-m_index),Math.abs(min_dist));
            }
            
        }
        return min_dist;
    }
    public static void main(String[] args) {
        int[] num={2,3,4,5,5,3,5,7,4,3,2};
        System.out.println("=================递归查找数组中最大的值===================");
        int result=findMax(num,0);
        System.out.println(result);
        System.out.println("=================动态规划实现差值最大方法==================");
        int max=getMax1(num);
        System.out.println(max);
        System.out.println("=================两个元素中最小距离======================");
        System.out.println(minDistance(num,3,5));
        System.out.println("=================对数组的两个子有序段进行合并===============");
        int[] a={1,5,6,7,15,2,4,8,10,13,14};
//        sort(a,5);
        sort1(a,5);
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
        
    }
}