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]+" ");
		}
		
	}
}