关于递归的几个算法实现

1.个人所得稅(c#)

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace Tax
{
class Program
{
static double tax_fee = 0;
const double minus_money = 2000.0;

static void Main(string[] args)
{
Console.WriteLine(fun(8000 - minus_money, 1));
Console.ReadKey();
}

static double fun(double money, int i)
{
double[] num ={0,500,2000, 5000, 20000, 40000, 60000, 80000, 100000,double.MaxValue};
double[] tax_num = {0.05,0.10,0.15,0.20,0.25,0.30,0.35,0.40,0.45};
if (i > num.Length || money < 0)
return tax_fee;
tax_fee += Math.Min(num[i] - num[i - 1], Math.Max(money - num[i], money)) * tax_num[i - 1];
fun(money - num[i] + num[i - 1], ++i);
return tax_fee;
}
}
}

2.数据结构-通过邻接矩阵递归遍历无向图两点间所有的路径长度及节点序列(Java)

import java.util.ArrayList;

public class Graph

{

public final int MAX_VERTEX = 9;

private Vertex[] vertexList = new Vertex[MAX_VERTEX];

private int matrix[][] = new int[MAX_VERTEX][MAX_VERTEX];

private static int vertexNum = 0;

private static int sum = 0;

private ArrayList<Integer> shortestValue = new ArrayList<Integer>();

private ArrayList<String> queue = new ArrayList<String>();

public ArrayList<String> shortestWay = new ArrayList<String>();

private int min = 0;

public Graph()

{

for(int i = 0; i < MAX_VERTEX;i++)

{

for(int j = 0;j < MAX_VERTEX;j++)

{

matrix[i][j] = 0;

}

}

}

class Vertex

{

public char name;

public boolean visited;

public Vertex(char name)

{

this.name = name;

visited = false;

}

}

public void addVertex(char name)

{

vertexList[vertexNum++] = new Vertex(name);

}

public void addEdge(char start,char end,int value)

{

int startNum = find(start);

int endNum = find(end);

if(startNum != -1 && endNum != -1)

{

matrix[startNum][endNum] = value;

matrix[endNum][startNum] = value;

}

}

public int find(char name)

{

for(int i = 0; i < vertexList.length;i++)

{

if(vertexList[i].name == name)

return i;

}

return -1;

}

public void printMatrix()

{

for(int i = 0; i < MAX_VERTEX;i++)

{

for(int j = 0;j < MAX_VERTEX;j++)

{

System.out.print(matrix[i][j] + " ");

}

System.out.println();

}

}

public int findMinWay(char startVertex,char endVertex)

{

int value;

int start = find(startVertex);

int end = find(endVertex);

sum = 0;

min = 99999;

shortestValue.clear();

queue.clear();

shortestWay.clear();

findMinWay(start,end);

value = findMin(shortestValue);

return value;

}

@SuppressWarnings("unchecked")

public void findMinWay(int start,int end)

{

vertexList[start].visited = true;

queue.add(vertexList[start].name+"");

if(start == end)

{

for(int i = 0;i < queue.size();i++)

System.out.print(queue.get(i) + " ");

System.out.println(sum);

shortestValue.add(sum);

vertexList[start].visited = false;

if(shortestValue.get(shortestValue.size() - 1) < min)

{

min = shortestValue.get(shortestValue.size() - 1);

shortestWay = (ArrayList<String>)queue.clone();

}

queue.remove(queue.size() - 1);

return;

}

for(int i = 0; i < vertexList.length;i++)

{

if(matrix[start][i] != 0 && vertexList[i].visited == false)

{

sum += matrix[start][i];

findMinWay(i,end);

sum -= matrix[start][i];

}

}

vertexList[start].visited = false;

queue.remove(queue.size() - 1);

return;

}

private int findMin(ArrayList<Integer> value)

{

int min = 9999999;

for(int i = 0; i < value.size();i++)

{

if(value.get(i) >= 0 && value.get(i) < min)

{

min = value.get(i);

}

}

return min;

}

}