文章列表
redmine安装时，一定会要注意版本问题。branch下面有很多旧版本的redmine backlog
安装backlog时，出现缺少***插件时，运行下面的命令：
rake redmine:backlogs:install
gem install ***
#include <stdio.h>
#include "String.h"
int BF(SqString s, SqString t)
{
int i=0,j=0,k;
while(i<s.len && j<t.len)
{
if(s.ch[i] == t.ch[i])
{
i++;
j++;
}
else
{
i = i-j+1;
j = 0;
}
}
if(j = t.len)
k = i - t.len;
else ...
#include <stdio.h>
#include "String.h"
#define MaxSize 100
void getNext(SqString t, int next[])
{
int j,k;
j = 0;
k = -1;
next[0] = -1;
while(j<t.len-1)
{
if( k == -1 || t.ch[j] == t.ch[k])
{
j++;
k++;
next[j] = k;
if(t.ch[j] != t.ch[k] ...
求解迷宫路径时，使用的是循环队列，所以出队只是修改了方块在队列里的下标，并没有真正意义上的出队。
思路是：
1）先将入口（1,1）入队，在队列不为空时循环进行出队，称出队方块为当前方块；
2）如果当前方块是出口（8,8），则输出路径；
3）如果当前方块不是出口，则将当前方块邻近可走的方块全部入队，入队时要保存方块的mg[i][j]值为-1，以免重复走，并保存方块的pre值，即当前队列的front，表明上一方块在队列的中下标值，这样方便倒推路径时可通过当前方块找到上一方块。
4）输出时，通过输出当前方块，然后根据当前方块的pre值输出上一方块。
#include <st ...
注意di的运用，每个栈元素都记录了di值，通过while循环则不会重复找到上次已找过的路径。
总结：利用栈来解决迷宫的问题，是深度优先搜索。首先将入口入栈，然后寻找该入口下一步可走的方块（不仅要将方块入栈，还要记录该方块的方位，因此就像上面所说的一样，要注意di的运用，通过while循环，就不会重复找到上次已经招工的路径）。
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 100
#define M 8
#define N 8
struct
{
int i;
int j;
in ...
合并LA，LB两个线性表到线性表LC中：
LinearList.h
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 20
typedef struct
{
int elem[MaxSize];
int length;
}SqList;
void initList(SqList* &L)
{
L = (SqList *)malloc(sizeof(SqList));
L->length = 0;
}
void Destory(SqList* & ...
选择排序：
#include <stdio.h>
void SelectSort(int A[], int n)
{
int i = 0;
for(i=0;i<n-1;i++)
{
int min = A[i];
int key = i;
//int j = i;
for(int j=i;j<n;j++)
{
if(A[j] < min)
{
min = A[j];
key = j;
}
}
A[key] = A[i];
A[i] = min; ...
选择排序：
#include <stdio.h>
void InsertSort(int A[], int n)
{
for(int i=0;i<n;i++)
{
int temp = A[i];
int j = i-1;
while(j>=0 && temp<A[j])
{
A[j+1] = A[j]; //根据temp<A[j],将数据向右移位
j--;
}
A[j+1] = temp; //将temp插入在正确的位置
}
}
...
冒泡排序：
#include <stdio.h>
#include <stdlib.h>
void BubbleSort(int A[],int n)
{
for(int i=0;i<n;i++)
{
int flag = 0;
for(int j=i;j<n;j++)
{
if(A[j]>A[j+1]) //大的下沉，则从第一个循环
{
int temp = A[j];
A[j] = A[j+1];
A[j+1] = temp;
flag = ...
public class ArrayCyclicShift {
/**
* 设计一个算法，把一个含有N个元素的数组循环右移K位，要求时间复杂度为O(N),且只允许使用两个附加变量
* 假设把abcd1234循环右移4位
*/
public static void main(String[] args) {
char[] A = {'a','b','c','d','1','2','3','4'};
System.out.println("The Original Array is : " );
Print(A);
...
最长公共子串
- 博客分类：
- Dynamic Programming
/*
* 好吧，下一题就是LCSubstring.
* Substring的特点就是必须是连续的。
*例如X=<A,B,C,D,E>,Y=<B,C,D,A,B>，则LCSubstring为<B,C,D>
*/
public class LongestCommonSubstring {
static String X = " " + "ABCDEABC";
static String Y = " " + "BCDABEAB";
publ ...
最长递增子序列
- 博客分类：
- Dynamic Programming
求数组中最长递增子序列
写一个时间复杂度尽可能低的程序，求一个一维数组（N个元素）中的最长递增子序列的长度。
例如：在序列1，-1，2，-3，4，-5，6，-7中，其最长的递增子序列为1，2，4，6。
public class LongestIncreasingSequence {
/**
*求数组中最长递增子序列
写一个时间复杂度尽可能低的程序，求一个一维数组（N个元素）中的最长递增子序列的长度。
例如：在序列1，-1，2，-3，4，-5，6，-7中，其最长的递增子序列为1，2，4，6
*/
...
X=<A,B,C,B,D,A,B>
Y=<B,D,C,A,B,A>
那么，<B,C,B,A> 或者 <B,D,A,B>都是LCS.因为，它们都是X的subsequence，也是Y的subsequence。并且，其长度都为4，达到了最大了。而<B,C,A>则是common subsequence,但不是LCS，因为，其长度只有3.
所以，现在的问题是给定X和Y，要你输出LCS的长度为多少。算法复杂度要求是O(mn),m,n分别是字符串X和Y的长度。
即实现函数public static int LCS(String x,S ...
package BinarySearch;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class BinarySearch {
public static void main(String[] args) {
Scanner scanner = null;
try {
scanner = new Scanner(new File("./binarysearch.txt"));
} cat ...