java m取n 重复 不重复 排列组合 for循环嵌套递归

实验一1．实验目的掌握Java语言基本语法，掌握基本数据类型的使用方法；熟练运用分支、循环等语句控制程序流程；掌握数组类型的声明和动态内存申请，理解数组的引用模型；熟悉String类中的方法。

掌握MyEclipse集成开发环境中编辑、编译、运行和调试程序的操作。

2．实验要求按照实验内容编写程序、编译、运行、调试，撰写实验报告。

3．实验内容。

（1）用递归方法求n个数的无重复全排列。

public class Permutation{private int[] table;public Permutation(int n) //构造方法{if (n>0){table = new int[n];for (int i=0;i<n;i++)table[i] = i+1;permute(n);}elsetable = null;}private void output() //输出数组元素{for (int i=0;i<table.length;i++)System.out.print(" "+table[i]);System.out.println();}private void swap(int i,int j) //交换数组两个元素值{if (table!=null && i>=0 && i<table.length && j>=0 && j<table.length){int temp = table[i];table[i] = table[j];table[j] = temp;}}private void permute(int n) //用递归方法求n个数的无重复全排列{if (n==1)this.output();else{permute(n-1);for (int j=0;j<n-1;j++){swap(n-1,j);permute(n-1);swap(n-1,j);}}}public static void main(String args[]){new Permutation(3);}}程序运行结果如下：1 2 32 1 33 2 12 3 11 3 23 1 2（2）黄金分割数0.618与美学有重要的关系。

C语⾔------排列组合组合情况（重复和不重复）组合不重复数问题引⼊：1.不重复的情况：例如ABCDE，让你从⾥⾯选出3个，问你⼀共有多少种可能，我们可以直接递归进⾏列举⼀共有多少种。

下⾯看代码：#include<stdio.h>int m,n;int f(int m,int n) //共有m个球取n个球{if(n == m){ //当堆⾥的数⽬和我们想拿的相同时只有⼀种情况return1;}if(n == 0){ //n=0 也是⼀种取法return1;}return f(m-1,n-1) + f(m-1,n); //从m-1的堆⾥取球取到我们想要的再取n-1个//否则再取n}int main(){printf("%d",f(5,3));return0;}组合重复数问题引⼊：2 重复情况：例如AABBBC ，让你从这些字母中选出三个进⾏组合，你肯定不能枚举，这样你会发现打印出来有重复的。

#include<stdio.h>int data[3];int x[3];int min(int a,int b) //返回最⼩值{if(a > b){return b;}if(b > a){return a;}}void work(int x[]) //打印数组{int i;for(i=0;i<3;i++){printf("%d",x[i]);}printf("\n");}void f(int data[],int x[],int k,int goal) //k为当前考虑的位置//goal距⽬标剩余位置{int i;if(k==3){if(goal == 0){work(x);}return;}for(i=0;i<=min(data[k],goal);i++){x[k] = i;f(data,x,k+1,goal-i);}x[k] = 0; //回溯}int main(){int data[3]={2,3,1}; //每个元素的最⼤个数int x[3]; //每个元素取到的个数f(data,x,0,3);return 0;}实例：2016年蓝桥杯代码填空抽签抽签X星球要派出⼀个5⼈组成的观察团前往W星。

递归、嵌套for循环、map集合⽅式实现树形结构菜单列表查询有时候，我们需要⽤到菜单列表，但是怎么样去实现⼀个菜单列表的编写呢，这是⼀重要的问题。

⽐如我们需要编写⼀个树形结构的菜单，那么我们可以使⽤JQuery的zTree插件：例如现在需要编写⼀个这样的菜单列表。

那么就可以使⽤JQuery的zTree插件。

先看⼀下数据库表结构。

CREATE TABLE `permission` (`id` int(11) NOT NULL AUTO_INCREMENT,`name` varchar(255) DEFAULT NULL,`pid` int(11) DEFAULT NULL,`url` varchar(255) DEFAULT NULL,PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;1、前端页⾯。

<div class="panel-body"><ul id="permissionTree" class="ztree"></ul></div><script>$(function () {var setting = {async: {enable: true,url:"${APP_PATH}/permission/loadData",autoParam:["id", "name=n", "level=lv"],otherParam:{"otherParam":"zTreeAsyncTest"},}};//树形结构$.fn.zTree.init($("#permissionTree"), setting);});</script>2、在这⾥呢，我使⽤的是ssm框架。

java循环和递归在Java编程中，循环和递归是两种常用的控制结构，用于解决重复性的任务和处理递归问题。

循环可以用来重复执行一段代码，而递归则是通过调用自身来解决问题。

本文将介绍Java中的循环和递归的概念、用法和一些常见的应用场景。

一、循环的概念和用法循环是一种重复执行一段代码的控制结构。

在Java中，常见的循环结构有for循环、while循环和do-while循环。

1. for循环for循环是一种在已知循环次数的情况下重复执行一段代码的结构。

它的语法如下：```for (初始化表达式; 循环条件; 更新表达式) {// 循环体}```其中，初始化表达式用于初始化循环变量；循环条件是一个布尔表达式，用于判断是否继续执行循环；更新表达式用于更新循环变量的值。

for循环的执行顺序是先执行初始化表达式，然后判断循环条件，如果为真则执行循环体，然后执行更新表达式，再次判断循环条件，以此类推，直到循环条件为假时结束循环。

for循环的一个常见应用是遍历数组或集合。

例如，可以使用for循环计算数组中元素的总和：```int[] nums = {1, 2, 3, 4, 5};int sum = 0;for (int i = 0; i < nums.length; i++) {sum += nums[i];}System.out.println("数组的总和为：" + sum);```2. while循环while循环是一种在未知循环次数的情况下重复执行一段代码的结构。

它的语法如下：```while (循环条件) {// 循环体}```while循环的执行顺序是先判断循环条件，如果为真则执行循环体，然后再次判断循环条件，以此类推，直到循环条件为假时结束循环。

while循环的一个常见应用是读取用户输入，直到满足特定条件为止。

例如，可以使用while循环验证用户输入的密码是否正确：```import java.util.Scanner;Scanner scanner = new Scanner(System.in);String password = "123456";String input;do {System.out.println("请输入密码：");input = scanner.nextLine();} while (!input.equals(password));System.out.println("密码正确！");```3. do-while循环do-while循环是一种在未知循环次数的情况下重复执行一段代码的结构，与while循环的区别在于它先执行一次循环体，然后再判断循环条件。

1.使用循环求1-100之间偶数的和public class Example {public static void main(String[] args) {int i=1;int sum=0;//for 里面有if语句求1-100之间偶数的和2+4+6+8+ (100)for(;i<=100;i++){if(i%2==0){sum=sum+i;}}System.out.println("这个是1-100偶数的和sum="+sum+"i="+i);}}2.使用循环求1-100之间奇数的和public class Example {public static void main(String[] args) {int sum=0;//for 里面有if语句求1-100之间奇数的和1+3+5+7+ (99)for(int i=1;i<=100;i++){if(i%2==1) //i%2!=1{sum=sum+i;}}System.out.println("这个是1-100奇数的和sum="+sum);}}3.使用循环嵌套打印3行10列的星号public class Example {public static void main(String[] args) {int i,j;for(i=1;i<=3;i++){for(j=1;j<=10;j++){System.out.print("*");}System.out.println("\n");}}}4.使用循环嵌套打印3行每行与行数个数一样的星号public class Example {public static void main(String[] args) { int i,j;for(i=1;i<=5;i++){for(j=1;j<=i;j++){System.out.print("*");}System.out.println("\n");}}}。

JAVA随机数之多种方法从给定范围内随机N个不重复数在Java中，我们可以使用多种方法从给定范围内随机生成N个不重复的数。

下面将详细介绍三种常用的方法：使用集合、Fisher-Yates洗牌算法和递归。

1.使用集合：使用集合可以保证生成的数不重复。

我们可以使用Java中的HashSet类来完成这个任务。

算法如下：（1）创建一个HashSet对象来存储生成的数。

（2）生成一个随机数，并检查是否在HashSet中已经存在。

（3）如果不存在，将随机数添加到HashSet中，并继续生成下一个随机数，直到HashSet中的元素个数达到N。

（4）返回HashSet中的元素作为结果。

代码示例：```javaimport java.util.HashSet;import java.util.Random;public class RandomNumberGeneratorpublic static HashSet<Integer> generateRandomNumbers(int min, int max, int count)HashSet<Integer> numbers = new HashSet<>(;Random random = new Random(;while (numbers.size( < count)int randomNumber = random.nextInt(max - min + 1) + min;numbers.add(randomNumber);}return numbers;}public static void main(String[] args)HashSet<Integer> randomNumbers = generateRandomNumbers(1, 10, 5);System.out.println(randomNumbers);}}```该代码可以生成1到10之间的5个不重复的随机数。

javalambda循环_使⽤Java8Lambda简化嵌套循环操作java lambda循环对于每个经常需要在Java 8（或更⾼版本）中使⽤多维数组的⼈来说，这只是⼀个快速技巧。

在这种情况下，您可能经常会以类似于以下代码的结尾：float[][] values = ...for (int i = 0; i < values.length; i++) {for (int k = 0; k < values[i].length; k++) {float value = values[i][k];// do something with i, k and value}}如果幸运的话，可以⽤for-each循环替换循环。

但是，循环内的计算通常需要索引。

在这种情况下，您可以提出⼀个简单的实⽤程序⽅法，如下所⽰：private void loop(float[][] values, BiConsumer<Integer, Integer> consumer) {for (int i = 0; i < values.length; i++) {for (int k = 0; k < values[i].length; k++) {consumer.accept(i, k);}}}现在，我们可以像这样循环遍历数组索引：float[][] values = ...loop(values, (i, k) -> {float value = values[i][k];// do something with i, k and value});这样，您可以使循环代码脱离主要逻辑。

当然，您应该更改所⽰的loop（）⽅法，使其适合您的个⼈需求。

补充知识：JAVA8-lambda表达式-并⾏流，提升效率的利器？写在前⾯的话在前⾯我们已经看过了⼀些流的处理，那么Lambda除了在写法上的不同，还有其它什么作⽤呢？当然有，就是数据并⾏化处理！它在某些场景下可以提⾼程序的性能。

java嵌套for循环优化_嵌套For循环性能优化案例1 案例描述某⽇，在JavaEye上看到⼀道⾯试题，题⽬是这样的：请对以下的代码进⾏优化for ( i = 0; i < 1000; i++)for (int j = 0; j < 100; j++)for (int k = 0; k < 10; k++)testFunction (i, j, k);2 案例从给出的代码可知，不论如何优化，testFunction执⾏的次数都是相同的，该部分不存在优化的可能。

那么，代码的优化只能从循环变量i、j、k的实例化、初始化、⽐较、⾃增等⽅⾯的耗时上进⾏分析。

⾸先，我们先分析原题代码循环变量在实例化、初始化、⽐较、⾃增等⽅⾯的耗时情况：变量实例化(次数)初始化(次数)⽐较(次数)⾃增(次数)i1110001000j100010001000 * 1001000 * 100k1000 * 1001000 * 1001000 * 100 * 101000 * 100 * 10该代码的性能优化就是尽可能减少循环变量i、j、k的实例化、初始化、⽐较、⾃增的次数，同时，不能引进其它可能的运算耗时。

3 解决过程从案例分析，对于原题代码，我们提出有两种优化⽅案：⽅案⼀：for (int i = 0; i < 10; i++)for (int j = 0; j < 100; j++)for (int k = 0; k < 1000; k++)testFunction (k, j, i);该⽅案主要是将循环次数最少的放到外⾯，循环次数最多的放⾥⾯，这样可以最⼤程度的(注：3个不同次数的循环变量共有6种排列组合情况，此种组合为最优)减少相关循环变量的实例化次数、初始化次数、⽐较次数、⾃增次数，⽅案耗时情况如下：变量实例化(次数)初始化(次数)⽐较(次数)⾃增(次数)i111010j101010 * 10010 * 100k10 * 10010 * 10010 * 100 * 100010 * 100 * 1000⽅案⼆：inti, j, k;for (i = 0; i < 10; i++)for (j = 0; j < 100; j++)for (k = 0; k < 1000; k++)testFunction (k, j, i);该⽅案在⽅案⼀的基础上，将循环变量的实例化放到循环外，这样可以进⼀步减少相关循环变量的实例化次数，⽅案耗时情况如下：变量实例化(次数)初始化(次数)⽐较(次数)⾃增(次数)i110j11010 * 10010 * 100k110 * 10010 * 100 * 100010 * 100 * 10004 解决结果那么，提出的优化⽅案是否如我们分析的那样有了性能上的提升了呢？我们编写⼀些测试代码进⾏验证，数据更能说明我们的优化效果。

java for循环嵌套语法格式
Java中的嵌套for循环的语法格式如下：
javafor (初始化表达式; 循环条件; 更新表达式) {
// 循环体语句
for (初始化表达式; 循环条件; 更新表达式) {
// 循环体语句
}
}
在这个嵌套for循环中，有两个for循环，一个在外层，一个在内层。

外层的for循环先执行一次，然后内层的for循环执行指定的次数。

内层的for循环结束后，外层的for循环继续执行，直到循环条件不再满足。

注意，在使用嵌套for循环时，需要注意控制变量的作用域和生命周期。

如果内层的for循环中的控制变量与外层的for循环中的控制变量同名，则在内层循环中定义的变量会覆盖外层循环中的变量。

因此，在编写嵌套for循环时，最好使用不同的变量名来避免这种情况。

组合数计算-java排列组合是计算应⽤经常使⽤的算法，通常使⽤递归的⽅式计算，但是由于n！的过于⼤，暴⼒计算很不明智。

⼀般使⽤以下两种⽅式计算。

⼀，递归的思想：假设m中取n个数计算排列组合数，表⽰为comb（m,n）。

那么comb（m，n）= comb（m-1，n-1）+comb（m-1，n）解释思想，从m个球中取出n个球可以分成两种情况相加，从m个球中取出⼀个球，如果它属于n，还需要从m-1中取出n-1个球；如果它不属于n，则需要从m-1中取出n个球根据这种思想可以通过递归的思想计算组合数：private static long comb(int m,int n){if(n==0)return 1;if (n==1)return m;if(n>m/2)return comb(m,m-n);if(n>1)return comb(m-1,n-1)+comb(m-1,n); return -1; //通过编译需要，数字⽆实际意义}适⽤递归计算，当数字较⼤时，递归深度过深，会相对耗时，甚⾄堆栈溢出。

如果对性能有要求，可以建⽴键-值对，存储计算结果，防⽌，反复计算。

static Map<String,Long> map= new HashMap<String, Long>();private static long comb(int m,int n){String key= m+","+n;if(n==0)return 1;if (n==1)return m;if(n>m/2)return comb(m,m-n);if(n>1){if(!map.containsKey(key))map.put(key, comb(m-1,n-1)+comb(m-1,n));return map.get(key);}return -1;}⼆，对数的计算思想：跟据定义，comb（m，n）=m！/（m-n）！n！两边取对数，log（comb（m，n））=log（m！/n！）-log（（m-n）！）计算之后，再通过exp计算最终结果。