算法题目

import java.io.File;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Stack;
import java.util.TreeSet;

public class DaoxunArray {
public static void main(String[] args) {
ArrayList str = Permutation(“abc”);
for (String data : str) {
System.out.println(data);
}
// 第一種方法
ArrayList list = new ArrayList();
Stack stack = new Stack();
for (int i = 0; i < 4; i++) {
list.add(i);
stack.push(list.get(i));
}
while (stack.size() != 0) {
list.add((Integer) stack.pop());
}
for (int i = list.size() / 2; i < list.size(); i++) {
System.out.println(list.get(i));
}

	// 第二種方法
	System.out.println(Fibonacci(5));
}
 
static int Fibonacci(int n) {
	if (n == 0) {
		return 0;
	} else if (n == 1 || n == 2) {
		return 1;
	} else {
		return Fibonacci(n - 1) + Fibonacci(n - 2);
	}
}
// 输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

static ArrayList<String> Permutation(String str) {
	ArrayList<String> result = new ArrayList<String>();// 根据返回类型需要
	if (str == null || str.length() == 0) {
		return result;
	}
	char[] chars = str.toCharArray();
	TreeSet<String> res = new TreeSet<String>(); // 用于排序输出
	getResult(chars, 0, str.length() - 1, res);
	result.addAll(res);// 添加到ArrayList
	return result;
}

public static void getResult(char[] chars, int start, int end, TreeSet<String> res) {
	if (start == end) {
		res.add(String.valueOf(chars));
	} else {
		for (int i = start; i <= end; i++) {
			swap(chars, start, i);// 换一位
			getResult(chars, start + 1, end, res);// 递归
			swap(chars, start, i);// 换回来，保证下次换位是正确的
		}
	}
}

public static void swap(char[] chars, int a, int b) {
	if (a == b) {// 因为会出现原位置与原位置交换，直接空即可

	} else {
		char temp = chars[a];
		chars[a] = chars[b];
		chars[b] = temp;
	}
}

// 第一个不重复出现的数据
public void firstnotappear() {
	String s = "asdfgsfhgjkaad";
	ArrayList<String> sb = new ArrayList<String>();
	sb.add(s);
	for (int i = 0; i < s.length(); i++) {
		// 后面的数不包含前面的数字
		if (s.substring(i + 1, s.length()).contains(s.substring(i, i + 1))
				// 前面的数字不包含后面的数字
				|| s.substring(0, i).contains(s.substring(i, i + 1))) {
			// 继续往前走
			continue;
		}
		// 不然就把这个数给输出来
		else {
			System.out.println(s.substring(i, i + 1));
			break;
		}
	}
}

// 最小的n个数
private static int[] min(int i, int[] source, int[] target) {
	for (int j = 0; j < source.length - 1; j++) {
		for (int k = 1; k < source.length - 1 - j; k++) {
			if (source[j] > source[k]) {
				int temp = source[k];
				source[k] = source[j];
				source[j] = temp;
			}
		}
	}
	for (int l = 0; l < 4; i++) {
		target[l] = source[l];
	}

	return target;
}

// 删除重复的数据
public void deltethesame() {
	LinkedList<Object> list = new LinkedList<>();
	int[] source = { 4, 5, 5, 7, 7, 8, 22, 44, 44, 56, 44 };
	for (int data : source) {
		list.add(data);
	}
	if (list != null || list.size() != 1) {
		for (int j = 0; j < list.size() - 1; j++) {
			for (int k = j + 1; k < list.size(); k++) {
				if (list.get(j) == list.get(k)) {
					list.remove(j);
				}
			}
		}
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
	}
}
//数组倒序相加求和
public void add() {
    int[] a= {1,2,3}, b= {6,7,8};
	LinkedList<Integer> link=new LinkedList<Integer>();
	LinkedList<Integer> link2=new LinkedList<Integer>();
	for(int data:a) {
		link.add(data);
	}
	for(int source:b) {
		link2.add(source);
	}
	int sum=0;
	for(int i=0;i<link.size();i++) {
		if(i==0) {
			sum=sum=(link.get(i)+link2.get(i))*1;;
		}
		if(i==1) {
			sum=sum+(link.get(i)+link2.get(i))*10;
		}
		if(i==2) {
			sum=sum+(link.get(i)+link2.get(i))*100;
		}
	}
	  System.out.println(sum);


//第一种方法判断回文
		// TODO Auto-generated method stub
		String source="1234566543219";
		StringBuffer sb=new StringBuffer(source);
		StringBuffer target=sb.reverse();
		if(target.toString().equals(source)) {
			System.out.println(source+"是回文");
		}
		else {
			System.out.println(source+"不是回文");
		}
//第二种方法判断回文
		int count=0;
		for(int i=0;i<sb.length();i++) {
			if(sb.charAt(i)==sb.charAt(sb.length()-1-i)) {
				count=count+1;
				continue;
			}
		}
			if(count==sb.length()) {
				System.out.println("这个是回文");
			}
			else {
				System.out.println("这个不是回文");
			}			
	}

// 遍历一个目录下的全部文件
public static void getFiles(String path) {
File file = new File(path);
// 如果这个路径是文件夹
if (file.isDirectory()) {
// 获取路径下的所有文件
File[] files = file.listFiles();
for (int i = 0; i < files.length; i++) {
// 如果还是文件夹 递归获取里面的文件 文件夹
if (files[i].isDirectory()) {
System.out.println(“目录：” + files[i].getPath());
getFiles(files[i].getPath());
} else {
System.out.println(“文件：” + files[i].getPath());
}
}
} else {
System.out.println(“文件：” + file.getPath());
}
}

//
//判断是不是数字的平方
/*double source=new Scanner(System.in).nextDouble();
for(int i=2;i<source/2;i++) {
	if(source/i==i) {
		System.out.println("这个是ok");
		break;
	}
	else {
		continue;
	}
}

//把数组某些数字往后移动
int[] a= {44,55,0,33,99,0,11};
ArrayList list=new ArrayList();
for(int data:a) {
list.add(data);
}
for(int i=0;i<list.size();i++) {
if(list.get(i)==0) {
list.remove(i);
list.add(0);
}
}
for(int data: list) {
System.out.println(data);
}*/
//快速排序
public static void sort(int[] a,int low,int high){
int start = low;
int end = high;
int key = a[low];

         while(end>start){
             //从后往前比较
             while(end>start&&a[end]>=key)  //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
                 end--;
             if(a[end]<=key){
                 int temp = a[end];
                 a[end] = a[start];
                 a[start] = temp;
             }
             //从前往后比较
             while(end>start&&a[start]<=key)//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
                start++;
             if(a[start]>=key){
                 int temp = a[start];
                 a[start] = a[end];
                 a[end] = temp;
             }
         //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
         }
         //递归
         if(start>low) sort(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1
         if(end<high) sort(a,end+1,high);//右边序列。从关键值索引+1到最后一个
     }

//

}