常用的算法在java里边怎么做，例

（一） 问题描述

给定由n个整数（可能为负整数）组成的序列a1，a2，a3，···，an，求该序列的子段和的最大值。当所有整数均为负整数是定义其最大子段和为0，一次定义，所求的最优质值为：max{0、max子段和}。

（二） 算法描述

动态规划法的基本思想：

动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。

算法设计：

#include "stdafxh"

int MaxSum(int a[],int n,int &Start,int&End){

intsum=0;

intb,t;

b=newint[n+1];

b[0]=0;

for(inti=1;i<=n;i++){

if(b[i-1]>0){

b[i]=b[i-1]+a[i];

}

else {

b[i]=a[i];t=i;

}

if(b[i]>sum){

sum=b[i];

Start=t;

End=i;

}

}

delete[]b;

returnsum;

}

int main(int argc, char argv[])

{

inta[7]={0,-2,11,-4,13,-5,-2},sum,Start,End,i;

sum=MaxSum(a,6,Start,End);

for(i=Start;i<=End;i++){

printf("%d ",a[i]);

}

printf("\n%d\n",sum);

getchar();

getchar();

return0;

银行家算法

一．程序说明：

本算法有3个进程，3类资源。初始可用资源向量为Available{10,8,7}，然后设置各进程的最大需求矩阵MAX以及分配矩阵Alloction,由此算出需求矩阵Need。然后判断当前系统资源分配是否处于安全状态，否则结束进程。最后，在当前分配资源后的系统安全时，选择一进程，并请求各类所需资源矩阵Request，尝试分配并修改资源分配状况，判断此进程请求是否该分配，进而进入安全算法判断是否能形成一个安全序列，如果有则分配，否则不分配。

二．程序代码：

算法类：

package bankerclass;

import javautilScanner;

public class BankerClass {

int[] Available = {10, 8, 7};

int[][] Max = new int[3][3];

int[][] Alloction = new int[3][3];

int[][] Need = new int[3][3];

int[][] Request = new int[3][3];

int[] Work = new int[3];

int num = 0;//进程编号

Scanner in = new Scanner(Systemin);

public BankerClass() {

// Max={{6,3,2},{5,6,1},{2,3,2}};

}

public void setSystemVariable(){//设置各初始系统变量，并判断是否处于安全状态。

setMax();

setAlloction();

printSystemVariable();

SecurityAlgorithm();

}

public void setMax() {//设置Max矩阵

Systemoutprintln("请设置各进程的最大需求矩阵Max：");

for (int i = 0; i < 3; i++) {

Systemoutprintln("请输入进程P" + i + "的最大资源需求量：");

for (int j = 0; j < 3; j++) {

Max[i][j] = innextInt();

}

}

}

public void setAlloction() {//设置已分配矩阵Alloction

Systemoutprintln("请设置请各进程分配矩阵Alloction：");

for (int i = 0; i < 3; i++) {

Systemoutprintln("晴输入进程P" + i + "的分配资源量：");

for (int j = 0; j < 3; j++) {

Alloction[i][j] = innextInt();

}

}

Systemoutprintln("Available=Available-Alloction");

Systemoutprintln("Need=Max-Alloction");

for (int i = 0; i < 3; i++) {//设置Alloction矩阵

for (int j = 0; j < 3; j++) {

Available[i] = Available[i] - Alloction[j][i];

}

}

for (int i = 0; i < 3; i++) {//设置Need矩阵

for (int j = 0; j < 3; j++) {

Need[i][j] = Max[i][j] - Alloction[i][j];

}

}

}

public void printSystemVariable(){

Systemoutprintln("此时资源分配量如下：");

Systemoutprintln("进程 "+" Max "+" Alloction "+" Need "+" Available ");

for(int i=0;i<3;i++){

Systemoutprint("P"+i+" ");

for(int j=0;j<3;j++){

Systemoutprint(Max[i][j]+" ");

}

Systemoutprint("| ");

for(int j=0;j<3;j++){

Systemoutprint(Alloction[i][j]+" ");

}

Systemoutprint("| ");

for(int j=0;j<3;j++){

Systemoutprint(Need[i][j]+" ");

}

Systemoutprint("| ");

if(i==0){

for(int j=0;j<3;j++){

Systemoutprint(Available[j]+" ");

}

}

Systemoutprintln();

}

}

public void setRequest() {//设置请求资源量Request

Systemoutprintln("请输入请求资源的进程编号：");

num= innextInt();//设置全局变量进程编号num

Systemoutprintln("请输入请求各资源的数量：");

for (int j = 0; j < 3; j++) {

Request[num][j] = innextInt();

}

Systemoutprintln("即进程P" + num + "对各资源请求Request：(" + Request[num][0] + "," + Request[num][1] + "," + Request[num][2] + ")");

BankerAlgorithm();

}

public void BankerAlgorithm() {//银行家算法

boolean T=true;

if (Request[num][0] <= Need[num][0] && Request[num][1] <= Need[num][1] && Request[num][2] <= Need[num][2]) {//判断Request是否小于Need

if (Request[num][0] <= Available[0] && Request[num][1] <= Available[1] && Request[num][2] <= Available[2]) {//判断Request是否小于Alloction

for (int i = 0; i < 3; i++) {

Available[i] -= Request[num][i];

Alloction[num][i] += Request[num][i];

Need[num][i] -= Request[num][i];

}

} else {

Systemoutprintln("当前没有足够的资源可分配，进程P" + num + "需等待。");

T=false;

}

} else {

Systemoutprintln("进程P" + num + "请求已经超出最大需求量Need");

T=false;

}

if(T==true){

printSystemVariable();

Systemoutprintln("现在进入安全算法：");

SecurityAlgorithm();

}

}

public void SecurityAlgorithm() {//安全算法

boolean[] Finish = {false, false, false};//初始化Finish

int count = 0;//完成进程数

int circle=0;//循环圈数

int[] S=new int[3];//安全序列

for (int i = 0; i < 3; i++) {//设置工作向量

Work[i] = Available[i];

}

Systemoutprintln("进程 "+" Work "+" Alloction "+" Need "+"Work+Available ");

while (count < 3) {

for (int i = 0; i < 3; i++) {

if (Finish[i]==false&&Need[i][0]<=Work[0]&&Need[i][1]<=Work[1]&&Need[i][2]<=Work[2]) {//判断条件

Systemoutprint("P"+i+" ");

for (int k = 0; k < 3; k++){

Systemoutprint(Work[k]+" ");

}

Systemoutprint("| ");

for (int j = 0; j<3;j++){

Work[j]+=Alloction[i][j];

}

Finish[i]=true;//当当前进程能满足时

S[count]=i;//设置当前序列排号

count++;//满足进程数加1

for(int j=0;j<3;j++){

Systemoutprint(Alloction[i][j]+" ");

}

Systemoutprint("| ");

for(int j=0;j<3;j++){

Systemoutprint(Need[i][j]+" ");

}

Systemoutprint("| ");

for(int j=0;j<3;j++){

Systemoutprint(Work[j]+" ");

}

Systemoutprintln();

}

}

circle++;//循环圈数加1

if(count==3){//判断是否满足所有进程需要

Systemoutprint("此时存在一个安全序列：");

for (int i = 0; i<3;i++){//输出安全序列

Systemoutprint("P"+S[i]+" ");

}

Systemoutprintln("故当前可分配！");

break;//跳出循环

}

if(count<circle){//判断完成进程数是否小于循环圈数

count=5;

Systemoutprintln("当前系统处于不安全状态，故不存在安全序列。");

break;//跳出循环

}

}

}

}

主类：

package bankerclass;

import javautilScanner;

public class TestBankerClass {

public static void main(String[] args) {

// TODO code application logic here

boolean Choose = true;

String C;

Scanner in = new Scanner(Systemin);

BankerClass T = new BankerClass();

Systemoutprintln("这是一个三个进程，初始系统可用三类资源为{10,8,7}的银行家算法：");

TsetSystemVariable();

while (Choose == true) {

TsetRequest();

Systemoutprintln("您是否还要进行请求：y/n");

C = innextLine();

if (CendsWith("n")) {

Choose = false;

}

}

}

}

三．随机运行过程

1

run：

这是一个三个进程，初始系统可用三类资源为{10,8,7}的银行家算法：

请设置各进程的最大需求矩阵Max：

请输入进程P0的最大资源需求量：

8 7 5

请输入进程P1的最大资源需求量：

5 2 5

请输入进程P2的最大资源需求量：

6 6 2

请设置请各进程分配矩阵Alloction：

晴输入进程P0的分配资源量：

3 2 0

晴输入进程P1的分配资源量：

2 0 2

晴输入进程P2的分配资源量：

1 3 2

Available=Available-Alloction

Need=Max-Alloction

此时资源分配量如下：

进程 Max Alloction Need Available

P0 8 7 5 | 3 2 0 | 5 5 5 | 4 3 3

P1 5 2 5 | 2 0 2 | 3 2 3 |

P2 6 6 2 | 1 3 2 | 5 3 0 |

进程 Work Alloction Need Work+Available

P1 4 3 3 | 2 0 2 | 3 2 3 | 6 3 5

P2 6 3 5 | 1 3 2 | 5 3 0 | 7 6 7

P0 7 6 7 | 3 2 0 | 5 5 5 | 10 8 7

此时存在一个安全序列：P1 P2 P0 故当前可分配！

请输入请求资源的进程编号：

0

请输入请求各资源的数量：

1 0 0

即进程P0对各资源请求Request：(1,0,0)

此时资源分配量如下：

进程 Max Alloction Need Available

P0 8 7 5 | 4 2 0 | 4 5 5 | 3 3 3

P1 5 2 5 | 2 0 2 | 3 2 3 |

P2 6 6 2 | 1 3 2 | 5 3 0 |

现在进入安全算法：

进程 Work Alloction Need Work+Available

P1 3 3 3 | 2 0 2 | 3 2 3 | 5 3 5

P2 5 3 5 | 1 3 2 | 5 3 0 | 6 6 7

P0 6 6 7 | 4 2 0 | 4 5 5 | 10 8 7

此时存在一个安全序列：P1 P2 P0 故当前可分配！

您是否还要进行请求：y/n

y

请输入请求资源的进程编号：

2

请输入请求各资源的数量：

0 1 0

即进程P2对各资源请求Request：(0,1,0)

此时资源分配量如下：

进程 Max Alloction Need Available

P0 8 7 5 | 4 2 0 | 4 5 5 | 3 2 3

P1 5 2 5 | 2 0 2 | 3 2 3 |

P2 6 6 2 | 1 4 2 | 5 2 0 |

现在进入安全算法：

进程 Work Alloction Need Work+Available

P1 3 2 3 | 2 0 2 | 3 2 3 | 5 2 5

P2 5 2 5 | 1 4 2 | 5 2 0 | 6 6 7

P0 6 6 7 | 4 2 0 | 4 5 5 | 10 8 7

此时存在一个安全序列：P1 P2 P0 故当前可分配！

您是否还要进行请求：y/n

n

成功生成（总时间：1 分钟 38 秒）

选择排序法：

public class TSort{

public static void main(String args[]){

int a[]={12,45,2,5,26,56};

for(int i=0;i<alength-1;i++){

int t;

for(int j=i+1;j<alength;j++){

if(a[i]>a[j]){

t=a[i];a[i]=a[j];a[j]=t;

}

}

}

for(int i=0;i<alength;i++){

Systemoutprint(a[i]+" ");

}

}

}

package f;

import javautil;

public class Main {

static public int print(String line){

String str=linesubstring(1,linelength()-1);

List<String> list=ArraysasList(strsplit("，"));

Systemoutprintln(list);

Set<String> set=new HashSet<String>();

setaddAll(list);

Systemoutprintln(set);

return setsize();

}

static public void main(String[] str){

String line="{苹果，香蕉，梨，葡萄，香蕉，樱桃，梨}";

print(line);

}

}

结果：

[苹果, 香蕉, 梨, 葡萄, 香蕉, 樱桃, 梨]

[葡萄, 香蕉, 樱桃, 梨, 苹果]

注意： ，是中文逗号

你在这里没有进行排序

public static void main(String[] args) throws InterruptedException {

//生成随机数组

int[] arr = new int[100];

for (int i = 0; i < 100; i++) {

arr[i] = (int) (Mathrandom() 100) + 1;

}

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

Systemoutprint(arr[i] + "\t");

//生成随机数组

//小到大排序

int num=0;//记录移动次数 根据你的意思这是会根据生成数组的不同而大小不一样的

for(int i=0;i<arrlength;i++){

for(int j=0;j<arrlength-i-1;j++){

if(arr[j]>arr[j+1]){

arr[j]=arr[j]+arr[j+1];

arr[j+1]=arr[j]-arr[j+1];

arr[j]=arr[j]-arr[j+1];

num++;

}

}

}

Systemoutprintln("\n一共移动"+num+"次，完成排序");

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

Systemoutprint(arr[i] + "\t");

}

以上就是关于常用的算法在java里边怎么做，例全部的内容，包括:常用的算法在java里边怎么做，例、求JAVA语言的银行家算法、初学者：用java程序写一个选择排序算法！等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！