我的算法学习(一)----数组的全排列

看见别人写出来美丽有用的代码,最终下定决心好好学习算法,在这里记录下自己学习的成果。

前两天看到数组的全排列,于是自己照着别人的想法实现了一下,感觉自己理解了,有点小高兴,记载一下。

/*
 * 数组的全排列*/
public class myAllSort {
	public static void sort(int[] number,int start,int end){

		int temp;
//		假设发现数组对掉元素到了最后一个,那么就输出,证明已经符合要求
		if(start==end)
		{
			print(number);
		}
//		依次将数组的第一个元素和后面的元素一一对调,然后第一次对掉之后递归,
//		将数组的第二个元素和他之后的元素对掉,最后一次进行
		/*
		 * 1  2  3  4-->1 2 3 4-->1 2 3 4
		 * 				    1 2 4 3
		 * 			  1 3 2 4-->1 3 2 4
		 * 				    1 3 4 2
		 *  			  1 4 3 2-->1 4 3 2
		 *  				    1 4 2 3
		 * 2  1  3  4
		 * 3  2  1  4
		 * 4  2  3  1
		 * */
		for(int i=start;i<end;i++){

			temp = number[start];
			number[start] = number[i];
			number[i] = temp;

			sort(number,start+1,end);
//			print(number);			//输出排序的全过程
//			将对掉之后的数组便会原来的顺序,以便下次
			temp = number[start];
			number[start] = number[i];
			number[i] = temp;
//			

		}
	}
	public static void print(int[] number){
		for(int i=0;i<number.length;i++)
		{
			System.out.print(number[i]+"--");
		}
		System.out.println();
	}

	public static void main(String[] args) {
		int[] number = {1,2,3,4};
		sort(number,0,number.length);

	}
}

另一种数组的选择排序方法,感觉这个思想对我非常实用,详细的出处给忘了。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/*
 * 从属注重选择几个数字进行排列
 * 比如:五个选三个的全排列
 * 算法原理:在数组中选取一个数字先存储到集合中,然后再依次选取其它数字,
 * */
public class ChooseServalFromNumber {
	public static final int  NUM = 4;

	public static void main(String[] args) {
		Object[] obj = new String[]{"1","2","3","4"};
		List<Object> list = Arrays.asList(obj);
		chooseNumberSort(list,new ArrayList<Object>());
	}
	public static void chooseNumberSort(List<Object> list,List<Object> target){
//		假设目标集合中的数字达到了我们需求的个数就输出
//		if(target.size()==NUM)
//			System.out.println(target+"--");

		if(target.size()==4)
			System.out.println(list+"  -->  "+target+"--输出");
//		else
//			System.out.println(list+"  -->  "+target);

		for(int i=0;i<list.size();i++){
			List<Object> newList = new ArrayList<Object>(list);
			List<Object> newTarget = new ArrayList<Object>(target);
			newTarget.add(newList.get(i));
			newList.remove(i);

			System.out.println(list+"  -->  "+target);

			chooseNumberSort(newList,newTarget);
		}
	}
}
/*
    输出结果:
[1, 2, 3, 4]  -->  []
[2, 3, 4]  -->  [1]
[3, 4]  -->  [1, 2]
[4]  -->  [1, 2, 3]
[]  -->  [1, 2, 3, 4]--输出
[3, 4]  -->  [1, 2]
[3]  -->  [1, 2, 4]
[]  -->  [1, 2, 4, 3]--输出
[2, 3, 4]  -->  [1]
[2, 4]  -->  [1, 3]
[4]  -->  [1, 3, 2]
[]  -->  [1, 3, 2, 4]--输出
[2, 4]  -->  [1, 3]
[2]  -->  [1, 3, 4]
[]  -->  [1, 3, 4, 2]--输出
[2, 3, 4]  -->  [1]
[2, 3]  -->  [1, 4]
[3]  -->  [1, 4, 2]
[]  -->  [1, 4, 2, 3]--输出
[2, 3]  -->  [1, 4]
[2]  -->  [1, 4, 3]
[]  -->  [1, 4, 3, 2]--输出
[1, 2, 3, 4]  -->  []
[1, 3, 4]  -->  [2]
[3, 4]  -->  [2, 1]
[4]  -->  [2, 1, 3]
[]  -->  [2, 1, 3, 4]--输出
[3, 4]  -->  [2, 1]
[3]  -->  [2, 1, 4]
[]  -->  [2, 1, 4, 3]--输出
[1, 3, 4]  -->  [2]
[1, 4]  -->  [2, 3]
[4]  -->  [2, 3, 1]
[]  -->  [2, 3, 1, 4]--输出
[1, 4]  -->  [2, 3]
[1]  -->  [2, 3, 4]
[]  -->  [2, 3, 4, 1]--输出
[1, 3, 4]  -->  [2]
[1, 3]  -->  [2, 4]
[3]  -->  [2, 4, 1]
[]  -->  [2, 4, 1, 3]--输出
[1, 3]  -->  [2, 4]
[1]  -->  [2, 4, 3]
[]  -->  [2, 4, 3, 1]--输出
[1, 2, 3, 4]  -->  []
[1, 2, 4]  -->  [3]
[2, 4]  -->  [3, 1]
[4]  -->  [3, 1, 2]
[]  -->  [3, 1, 2, 4]--输出
[2, 4]  -->  [3, 1]
[2]  -->  [3, 1, 4]
[]  -->  [3, 1, 4, 2]--输出
[1, 2, 4]  -->  [3]
[1, 4]  -->  [3, 2]
[4]  -->  [3, 2, 1]
[]  -->  [3, 2, 1, 4]--输出
[1, 4]  -->  [3, 2]
[1]  -->  [3, 2, 4]
[]  -->  [3, 2, 4, 1]--输出
[1, 2, 4]  -->  [3]
[1, 2]  -->  [3, 4]
[2]  -->  [3, 4, 1]
[]  -->  [3, 4, 1, 2]--输出
[1, 2]  -->  [3, 4]
[1]  -->  [3, 4, 2]
[]  -->  [3, 4, 2, 1]--输出
[1, 2, 3, 4]  -->  []
[1, 2, 3]  -->  [4]
[2, 3]  -->  [4, 1]
[3]  -->  [4, 1, 2]
[]  -->  [4, 1, 2, 3]--输出
[2, 3]  -->  [4, 1]
[2]  -->  [4, 1, 3]
[]  -->  [4, 1, 3, 2]--输出
[1, 2, 3]  -->  [4]
[1, 3]  -->  [4, 2]
[3]  -->  [4, 2, 1]
[]  -->  [4, 2, 1, 3]--输出
[1, 3]  -->  [4, 2]
[1]  -->  [4, 2, 3]
[]  -->  [4, 2, 3, 1]--输出
[1, 2, 3]  -->  [4]
[1, 2]  -->  [4, 3]
[2]  -->  [4, 3, 1]
[]  -->  [4, 3, 1, 2]--输出
[1, 2]  -->  [4, 3]
[1]  -->  [4, 3, 2]
[]  -->  [4, 3, 2, 1]--输出

*/

我的算法学习(一)----数组的全排列

时间: 2024-10-10 17:21:12

我的算法学习(一)----数组的全排列的相关文章

算法学习(二) 全排列问题的非递归算法——模拟堆栈

前一段时间总结了全排列问题的几种递归解法,今天再总结一下如何通过对系统栈行为的模拟来非递归的实现全排列问题. 我们用一个数组stack[]来表示一个栈,用一个top指针来表示栈顶,用一个flags[]数组来标示每一个数字的可用性:用i来表示当前的状态. 初始状态top=0:i=-1:flags数组全为1: i递增,如果i没有越界并且flags[i]==1,那么就将i写入栈中,栈顶往前移动一位:最后把flags[i]赋值为0,i回溯到初始状态-1: 当栈顶越界,就将整个栈的信息打印出来,然后top

算法学习笔记 KMP算法之 next 数组详解

最近回顾了下字符串匹配 KMP 算法,相对于朴素匹配算法,KMP算法核心改进就在于:待匹配串指针 i 不发生回溯,模式串指针 j 跳转到 next[j],即变为了 j = next[j]. 由此时间复杂度由朴素匹配的 O(m*n) 降到了 O(m+n), 其中模式串长度 m, 待匹配文本串长 n. 其中,比较难理解的地方就是 next 数组的求法.next 数组的含义:代表当前字符之前的字符串中,有多大长度的相同前缀后缀,也可看作有限状态自动机的状态,而且从自动机的角度反而更容易推导一些. "前

[算法学习]给定一个整型数组,找出两个整数为指定整数的和(3)

问题描述: 设计一个类,包含如下两个成员函数: Save(int input) 插入一个整数到一个整数集合里. Test(int target) 检查是否存在两个数和为输入值.如果存在着两个数,则返回true,否则返回false 允许整数集合中存在相同值的元素 分析: 与[算法学习]给定一个整型数组,找出两个整数为指定整数的和(2)不同,这里需要算出的是存不存在这两个数,可以在上一篇的基础上修改一下数据结构,HashMap其中key是数值,value是数值个数,然后需要作两步判断,map中存在数

Javascript经典算法学习1:产生随机数组的辅助类

辅助类 在几个经典排序算法学习部分,为方便统一测试不同算法,新建了一个辅助类,主要功能为:产生指定长度的随机数组,提供打印输出数组,交换两个元素等功能,代码如下: function ArraySortUtility(numOfElements) { this.dataArr = []; this.pos = 0; this.numOfElements = numOfElements; this.insert = insert; this.toString = toString; this.cle

算法学习:后缀数组 height的求取

[定义] [LCP]全名最长公共前缀,两个后缀之间的最长前缀,以下我们定义 lcp ( i , j ) 的意义是后缀 i 和 j 的最长前缀 [z函数] 函数z [ i ] 表示的是,第 i 个后缀和字符串的最长前缀  [解决问题] 这两个算法都是在解决这个问题 即求后缀和字符串和后缀之间的最长公共前缀 但是有所不同的是, 后缀数组最终求出的是,字典序第 i 个后缀和第 i + 1 个后缀的最长公共前缀 z函数最终求出的是,第 i 个后缀和字符串的最长公共前缀 然后通过这个最长公共前缀求一些其他

周总结(2017.2.16):第一周算法学习。

周总结:算法学习总结之DFS和BFS 一:DFS算法 目的:达到被搜索结构的叶节点. 定义:假定给定图G的初态是所有的定点都没有访问过,在G中任选一定点V为初始出发点,首先访问出发点并标记,然后依次从V出发搜索V的每个相邻点W,若W未曾出现过,则对W进行深度优先遍历(DFS),知道所有和V有路径相通的定点被访问. 如果从V0开始寻找一条长度为4的路径的话: 思路步骤: 先寻找V0的所有相邻点:dis{v1,v2,v3},V1没有访问过,所以对V1进行深度遍历并将V1标记为访问过,此时路径长度为1

算法学习 - 01背包问题(动态规划C++)

动态规划 01背包 问题描述 求解思路 代码实现 放入哪些物品 代码 动态规划 我在上一篇博客里已经讲了一点动态规划了,传送门:算法学习 - 动态规划(DP问题)(C++) 这里说一下,遇到动态规划应该如何去想,才能找到解决办法. 最主要的其实是要找状态转移的方程,例如上一篇博客里面,找的就是当前两条生产线的第i个station的最短时间和上一时刻的时间关系. minTime(station[1][i]) = minTime(station[1][i-1] + time[i], station[

算法学习 - 链表的游标实现~ C++

链表的游标实现,就是用另外一种方法来访问链表,模拟游标. 在我学习的理解中,就是创建一个节点数组,模拟内存的排列,然后从其中来申请内存和释放内存.但是实际的内存没有被释放~ 下面直接贴代码了: // // main.cpp // CursorList // // Created by Alps on 14-7-27. // Copyright (c) 2014年 chen. All rights reserved. // #include <iostream> #define CursorSp

算法学习-1 插入排序

算法学习-1  插入排序 一.描述: 比如说我们玩扑克牌,规定每抓一张牌都要保证左边数字最小:抓第一张牌直接放手里就可以,抓第二张时如果比第一张小,则把它放到第一张牌的左边,假如每张抓来的牌放到手中都有固定位置,第一张为A[0],第二张为A[1],第三张为A[2],如果抓的第三张牌比第一张抓来的牌小,则将其放在A[0]处,对应的第二张牌就应该放在A[1],以此类推. 二.java代码实现 public class InsertSort { //排序后的数组 int sorted[]; publi