java算法题目

package test.kang;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * 算法题目
 * @author Administrator
 *
 */
public class Test_algorithm {

	public static void main(String[] args) {
		//		test01();//给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。
		//		test02();//在一个长度为n的数组里的所有数字都在0到n-1的范围内。输出重复数字
		//		test03();//找出所有和为S的连续正数序列
		//		test04();//给定一个NxN的矩阵，和矩阵的阶数N,请返回旋转后的NxN矩阵,这个我还没完成
		test05("ssdassdddddssss");//字符串压缩算法
	}

	/**
	 * 字符串压缩算法
	 * 例子：ssdassdddddssss 压缩后   ssdass5d4s
	 * 		saaasdfffasssddddsss 压缩后  s3asd3fa3s4d3s
	 * @return
	 */
	private static String test05(String source) {
		int num=1;
		String word="";
		String words="";
		for(int i=0;i<source.length();i++){
			String str_start=source.substring(i, i+1);
			String str_last=source.substring(i+1);
			System.out.println("提取首字符："+str_start);
			System.out.println("剩余字符串："+str_last);
			System.out.println("剩余字符串是否长度为0："+ (str_last.length()==0));
			
			
			//if(str_start.equals(str_last.substring(0, 1))){这个不行
			word = str_start;
			if(str_last.startsWith(str_start)){
				
				num++;
				System.out.println("首字符和剩余字符串首字符相同："+word);
			}else{
				if(num>2){
					words =words+num+word;
					
				}else if(num==2){
					words=words+word+word;
				}else{
					words=words+word;
				}
				
				num=1;
				System.out.println("words= "+words);
			}

		}
		System.out.println("字符串: "+source+" 压缩后为： "+words);
		return words;


	}

	/**
	 * 有一副由NxN矩阵表示的图像，这里每个像素用一个int表示，请编写一个算法，在不占用额外内存空间的情况下(即不使用缓存矩阵)，将图像顺时针旋转90度。
	 *	给定一个NxN的矩阵，和矩阵的阶数N,请返回旋转后的NxN矩阵,保证N小于等于500，图像元素小于等于256。
	 *	测试样例：
	 *		[[1,2,3],[4,5,6],[7,8,9]],3
	 *	返回：
	 *		[[7,4,1],[8,5,2],[9,6,3]]
	 * @return
	 */
	private static void test04() {
		int[][] matrix={{1,2,3},{4,5,6},{7,8,9}};
		int number=3;
		int[][] matrix_output=new int[number][3];

		for(int i=0;i<number;i++){
			for(int j=0;j<number;j++){
				if(number%2!=0){

				}


			}
		}
		for(int i=0;i<number;i++){
			System.out.println(Arrays.toString(matrix_output[i]));
		}

	}

	/**
	 * 给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，
	 * 那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： 
	 * {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， 
	 * {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。
	 * @return int[]
	 */
	private static int[] test01() {
		int[] arr=new int[]{2,3,4,2,6,2,5,1};
		int slide=3;
		int[] _slide = new int[slide];//窗口
		int[] output=new int[arr.length-slide+1];//要返回的所有窗口最大值的数组
		for(int a=0;a<arr.length-2;a++){

			_slide[0]=arr[a];
			_slide[1]=arr[a+1];
			_slide[2]=arr[a+2];
			//插入排序将最大的选出来
			int i,j,k;
			for(i=1;i<_slide.length;i++){
				k=_slide[i];
				for(j=i-1;j>=0&&k<_slide[j];j--){
					_slide[j+1]=_slide[j];
				}
				_slide[j+1]=k;//注意，由于上面for循环结束后会进行j--操作，所以这里要变为arr[j+1]，而不是arr[j]
			}
			//将当前窗口最大值存进output
			output[a]=_slide[_slide.length-1];
		}
		System.out.println(Arrays.toString(output));
		return output;
	}
	/**
	 * 在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。
	 * 也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，
	 * 那么对应的输出是重复的数字2或者3。
	 * @return
	 */
	private static void test02() {
		int[] arr=new int[7];
		for(int i=0;i<arr.length;i++){
			arr[i]=(int)(Math.random()*(arr.length));//随机生成0到7(不包括7)之间的数字
		}
		System.out.println(Arrays.toString(arr));


		Map<Integer,Integer> map=new HashMap<Integer,Integer>();//以键值对方式保存数字和出现的次数
		Set set=new HashSet();	//保存重复的数字的集合,Set是不含重复元素的集合，保证每个数字只保存一次
		for(int i=0;i<arr.length;i++){
			if(map.get(arr[i])==null){
				map.put(arr[i], 0);
			}
			map.put(arr[i], map.get(arr[i])+1);
			if(map.get(arr[i])>=2){
				set.add(arr[i]);
			}
		}

		Iterator iterator=set.iterator();
		while(iterator.hasNext()){
			System.out.println("重复数字： "+iterator.next());
		}


	}

	/**
	 * 小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。
	 * 但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就
	 * 得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出
	 * 所有和为S的连续正数序列? Good Luck! 
	 * @return ArrayList<int[]>
	 */
	private static ArrayList<int[]> test03() {
		int a=100;
		System.out.println(a/2);
		List<String> list=new ArrayList<String>();
		ArrayList<int[]> list_output = new ArrayList<int[]>();
		//找出因数对
		for(int i=2;i<(a/2);i++){
			if(a%i==0){
				int b=a/i;;
				if(b>=i){
					list.add(i+"-"+b);
					System.out.println(i+"-"+b);
				}

			}
		}

		//根据奇偶因数判断出值
		for(int i=0;i<list.size();i++){
			String[] strs=list.get(i).split("-");
			int n1=Integer.parseInt(strs[0]);
			int n2=Integer.parseInt(strs[1]);
			System.out.println("n1:"+n1+"  n2:"+n2);
			if(n1%2==0&&n2%2==0){//偶偶
				System.out.println("n1:"+n1+"  n2:"+n2+"不符合");
				continue;
			}
			if((n1%2!=0&&n2%2==0)||(n1%2!=0&&n2%2!=0)){//奇偶或者奇奇
				int[] arr=new int[n1];
				for(int j=0;j<n1;j++){
					arr[j]=n2-(n1-1)/2+j;
				}
				list_output.add(arr);
				System.out.println(Arrays.toString(arr));
			}
			if(n1%2==0&&n2%2!=0){//偶奇
				int[] arr=new int[n1*2];
				for(int j=0;j<n1*2;j++){
					arr[j]=(n2+1)/2-n1+j;
				}
				list_output.add(arr);
				System.out.println(Arrays.toString(arr));
			}

		}
		return list_output;
	}


}