「子集输出java」输出子集的程序
今天给各位分享子集输出java的知识，其中也会对输出子集的程序进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
- 1、java问题求解答~
- 2、用java编写程序输入一个字符串(包含空格)，统计其中所有出现过的所有字符，并按照频率高低的顺序排列输出
- 3、求java用回溯法解决子集和问题
- 4、用java编程：输入一个集合,可以有正数有负数,写一个程序 输出集合内所有数值的和最小的连续子集有一组数
- 5、用递归 求出一个string的所有子集 java
- 6、Java集合问题
java问题求解答~
首先说几点：
1 你的方法提炼有些不恰当，你的返回值设为一个Integer，这能返回什么呢？返回值可以有两种方式：1）你返回符合结果的开始数的下标(这里就是1)和最长的长度(这里是5)
2）直接就把符合条件的结果做成一个list返回出来(我就是采用这种方法)
2 对于注释，时间仓促点 ，代码里没写。但是：：：你要明白，写程序不是说开始出来就写，闷头写，最重要的是你一开始就要知道这个过程是怎样实现的，这里我简述下：
对于要符合你所描述的条件，要怎样去实现呢，首先我要从这个list的第一个数(2)开始，到后面找到第二个2，然后分别比较第一个2和第二个2后面的数，一直比较到不相等的两个数，记录长度(这里就是1，结果就是{2})；然后再从第二个数(5)开始，按照上面的方法比较，记录结果长度是5，也就是{5,5,6,6,7} 。。。。。就是这样比较下去，就能知道最长结果了
望采纳：：：
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) {
ListInteger list = new ArrayListInteger();
list.add(2);
.........
list.add(9);
ListInteger result = longestSub(list);
for (Integer i : result) {
System.out.print(i + "\t");
}
}
private static ListInteger longestSub(ListInteger list) {
ListInteger result = new ArrayListInteger();
int lflag, rflag, resultFrom, resultSize = 1, maxResultFrom = 0, maxResultSize = 1;
for (int i = 0; i list.size() - 1; i++) {
for (int j = i + 1; j list.size(); j++) {
if (list.get(i) == list.get(j)) {
resultFrom = i;
lflag = i + 1;
rflag = j + 1;
while (list.get(lflag++) == list.get(rflag++)) {
resultSize++;
}
if (resultSize maxResultSize) {
maxResultFrom = resultFrom;
maxResultSize = resultSize;
}
resultSize = 1;
}
}
}
for (int i = maxResultFrom; i maxResultFrom + maxResultSize; i++) {
result.add(list.get(i));
}
return result;
}
}
用java编写程序输入一个字符串(包含空格)，统计其中所有出现过的所有字符，并按照频率高低的顺序排列输出
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
public class Day02_A {
public static void main(String[] args) {
String str="The job requires an agile mind.";
init(str);
}
private static void init(String str) {
char[] arr=str.toCharArray();
LinkedHashMapCharacter,Integer tm=new LinkedHashMap();
for (int i = 0; i arr.length; i++) {
if(tm.containsKey(arr[i])) {
Integer a=tm.get(arr[i]);
a++;
tm.put(arr[i], a);
}else {
tm.put(arr[i],1);
}
}
ListEntryCharacter, Integer list = new ArrayListEntryCharacter, Integer(tm.entrySet());
Collections.sort(list,new ComparatorMap.EntryCharacter,Integer() {
public int compare(EntryCharacter, Integer o1, EntryCharacter, Integer o2) {
return o2.getValue().compareTo(o1.getValue());
}
});
for(int i=0;ilist.size();i++) {
Map.EntryCharacter, Integer me=list.get(i);
String key=me.getKey()+"",value=me.getValue()+"";
if(key.equals(" ")) {
key="#";
}
if((i+1)%4!=0) {
System.out.print(key+"-"+value+"\t");
}else {
System.out.println(key+"-"+value);
}
}
}
}
求java用回溯法解决子集和问题
很简单 思路就是循环集合 先不同的2个数相加 然后3个 一直到s.length个相加 if(sum==c)输出
用java编程：输入一个集合,可以有正数有负数,写一个程序 输出集合内所有数值的和最小的连续子集有一组数
package com.arc.test;
public class MiniArrayTest {
public static void main(String[] args) {
int[] arr = {-15, 3, 3, -20, 1, -4};
getMiniArray(arr);
}
public static void getMiniArray(int[] arr){
int startIndex = 0;
int endIndex = 0;
int temp = Integer.MAX_VALUE;
int min = 0;
// 如果数组长度为1或2，则最小的连续子集就是自己
if(arr.length = 2){
for(int i = 0; i arr.length; i++){
System.out.println(arr[i] + ",");
}
return;
}
// 用index标注出现负数的数组下标，依次比较结果，index将停留在数值最小的地方
// 此时，时间复杂度是O(n)
for(int i = 0; i arr.length; i++){
if(arr[i] 0){
min += arr[i];
if(min = temp){
startIndex = endIndex;
endIndex = i;
temp = min;
min = arr[endIndex];
}
}else{
min += arr[i];
}
}
// 如果endIndex 0，说明数组中有负数，则把startIndex和endIndex之前的元素打印出来
// 这里，最大时间复杂度(n)
// 所以，总的时间复杂度2O(n)，也可以当作O(n)
if(endIndex 0){
if(startIndex == 0){
for(int i = startIndex; i = endIndex; i++){
System.out.print(arr[i] + ",");
}
}
// 如果endIndex = 0，说明数组中没有负数，则把连续的最小的两个整数输出，就是最小连续子集合
// 这里，最大时间复杂度(n)
// 所以，总的时间复杂度2O(n)，也可以当作O(n)
}else{
endIndex = 1;
min = arr[0] + arr[1];
for(int i = 2; i arr.length; i++){
if(arr[i - 1] + arr[i] = min){
min = arr[i] + arr[i - 1];
endIndex = i - 1;
}
}
System.out.println(arr[endIndex - 1] + "," + arr[endIndex]);
}
}
}
用递归 求出一个string的所有子集 java
其实问题还是比较明显的，比如subsets.add(firstWord);这句话在for循环中重复执行，但是显然firstWord每次都是word.substring(0, 1);而在整个for循环中，你又没有对word重新赋值过。这也就是为什么你的输出有那么多相同的字符串吧
另外，理论上你每次新建一个SubsetGenerator，就不能算递归了
public static ArrayListString getSubSequences(String word) {
ArrayListString list = new ArrayListString();
doGetSubSequences(word, "", list);
return list;
}
private static void doGetSubSequences(String word, String s,
ArrayListString list) {
if (word.length() == 0) {
list.add(s);
return;
}
String tail = word.substring(1);
doGetSubSequences(tail, s, list);
doGetSubSequences(tail, s + word.charAt(0), list);
}
Java集合问题
我猜想是因为父类改变了，但底层是没有通知子集的，所以需要重新进行截取，可以debug看看变化。
子集输出java的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于输出子集的程序、子集输出java的信息别忘了在本站进行查找喔。