大数据开发 --- 算法刷题篇

⏳环境：window10、CentOs7、VMware15.5

📃专栏：刷题篇（力扣算法题）

🎯选自：大数据开发（java）

本专栏：仅用于自己的刷题记录。

1. 数字次数题

(1) 题目136. 只出现一次的数字

限制点：
提示：
·1 <= nums.length <= 3 * 104
·-3 * 104 <= nums[i] <= 3 * 104
·除了某个元素只出现一次以外，其余每个元素均出现两次。

知识点：
·交换律：a ^ b ^ c <=> a ^ c ^ b
·任何数于0异或为任何数 0 ^ n => n
·相同的数异或为0: n ^ n => 0
var a = [2,3,2,4,4]
2 ^ 3 ^ 2 ^ 4 ^ 4等价于 2 ^ 2 ^ 4 ^ 4 ^ 3 => 0 ^ 0 ^3 => 3

（2） 连续子数组

1.声明数组：

举例：数组a:int[] a={1,2,3};

那么，
它的所有子序列：{1}，{2}，{1，2}，{3}，{1，3}，{2，3}，{1，2，3}
它的连续子数组：{1}，{1，2}，{1，2，3}，{2}，{2，3}，{3}
它的所有排列：{1，2，3}，{1，3，2}，{2，1，3}，{3，1，2}，{2，3，1}，{3，2，1}

1） 它的所有子序列：

public class Main{
	
	public static void main(String args[]) {
		int[] a= {1,2,3};
		ArrayList<ArrayList<Integer>> list=getSubArray(a,a.length);
		//输出列表：
		for (int i=0;i<list.size();i++) {
			ArrayList<Integer> mList=list.get(i);
			for (int j=0;j<mList.size();j++) {
				System.out.print(mList.get(j)+" ");
			}
			//换行
			System.out.println();
			
		}
	}
	
	private static ArrayList<ArrayList<Integer>> getSubArray(int[] arr,int length) {
		ArrayList<ArrayList<Integer>> bList=new ArrayList<>();
		int mark=0;
		int nEnd=1<<length;
		boolean bNullset=false;
		for (mark=0;mark<nEnd;mark++) {
			ArrayList<Integer> aList=new ArrayList<>();
			bNullset=true;
			for (int i=0;i<length;i++) {
				if (((1<<i)&mark)!=0) {
					bNullset=false;
					aList.add(arr[i]);
				}
			}
			bList.add(aList);
		}
		return bList;
	}
}

2. 数组所有的连续子序列

public class Main{
	
	public static void main(String args[]) {
		String str="123";
		allContinuousSubArray(str);
		
	}
	
	private static void allContinuousSubArray(String str) {
		int i,j,k;
		int num=str.length();
		for (i=0;i<num;i++) {
			for (j=i;j<num;j++) {
				for (k=i;k<=j;k++) {
					System.out.print(str.charAt(k)+" ");
				}
				System.out.print(" ");
			}
			System.out.println();
		}
	}
}

3) 对所有元素进行组合排列

 
 
public class Main{
	
	public static void main(String args[]) {
		
		String str="123";
		permutation(str);
	}
	
	private static void permutation(String str) {
		if (str==null) {
			return ;
		}
		
		permutation(str.toCharArray(),0);
	}
	
 
	private static void permutation(char[] chars, int pos) {
		if(pos == chars.length - 1){
			System.out.println(chars);
		}
 
		for(int i = pos; i < chars.length; i++){
 
			//首部字符和它后面的字符（包括自己）进行交换
 
			char temp = chars[i];
			chars[i] = chars[pos];
			chars[pos] = temp;
 
			//递归求后面的字符的排列
 
			permutation(chars, pos+1);
			
			//由于前面交换了一下，所以chs的内容改变了，我们要还原回来
			temp = chars[i];
			chars[i] = chars[pos];
			chars[pos] = temp;
 
		}
	}
}

 
/** 1、数组元素的全组合 */
 
public void combination(char[] chars) {
 
	char[] subchars = new char[chars.length]; // 存储子组合数据的数组
 
	// 全组合问题就是所有元素(记为n)中选1个元素的组合, 加上选2个元素的组合...加上选n个元素的组合的和
 
	for (int i = 0; i < chars.length; ++i) {
 
		final int m = i + 1;
 
		combination(chars, chars.length, m, subchars, m);
 
	}
 
}
 
 
/**
 * n个元素选m个元素的组合问题的实现. 原理如下: 从后往前选取, 选定位置i后, 再在前i-1个里面选取m-1个. 如: 1, 2, 3, 4,
 * 5 中选取3个元素. 1) 选取5后, 再在前4个里面选取2个, 而前4个里面选取2个又是一个子问题, 递归即可; 2) 如果不包含5,
 * 直接选定4, 那么再在前3个里面选取2个, 而前三个里面选取2个又是一个子问题, 递归即可; 3) 如果也不包含4, 直接选取3,
 * 那么再在前2个里面选取2个, 刚好只有两个. 纵向看, 1与2与3刚好是一个for循环, 初值为5, 终值为m. 横向看,
 * 该问题为一个前i-1个中选m-1的递归.
 */
 
public void combination(char[] chars, int n, int m, char[] subchars,
 
		int subn) {
 
	if (m == 0) { // 出口
 
		for (int i = 0; i < subn; ++i) {
 
			System.out.print(subchars[i]);
 
		}
 
		System.out.println();
 
	} else {
 
		for (int i = n; i >= m; --i) { 
		// 从后往前依次选定一个
			subchars[m - 1] = chars[i - 1]; // 选定一个后 
			combination(chars, i - 1, m - 1, subchars, subn); // 从前i-1个里面选取m-1个进行递归
		}
	}
}
 

参考：https://blog.csdn.net/yaoyaoyao_123/article/details/100916422