看完你的,自己写了一个.很简陋.你的改动比较大.一时半会改不了.
你的写好了.改动有点大.鼠标事件mousePressed()中实现移动.由于时间没做优化,主要处理方法是判断当前listenerPanel的上下左右是否存在上面是0的listenerPanel,存在则交换上面数字及背景颜色.自己可以优化下里面代码,
思路：
PuzzleTile jb = (PuzzleTile) e.getSource();
for(int i=0;ilistenerPanel.length;i++){
if(jb.equals(listenerPanel[i])){
//判断当前listenerPanel[i]上下左右是否存有listenerPanel的上面数字是0的,如果存在
则把当前的listenerPanel[i]的背景颜色及数字与上面是0 的交换.判断周围是否存在有点及是否交换有点复杂.
}
代码修改如下：少量注释
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import javax.swing.*;
public class PuzzleTile extends JPanel{
private String tileNumber;
public PuzzleTile(int number) {
super();
if (number == 0) {
this.setBackground(Color.white);
else {
this.setBackground(Color.darkGray);
this.tileNumber = "" + number;
public void setTitleNumber(int tileNumber){//设置上面的数字
this.tileNumber=tileNumber+"";
public int getTitleNumber(){//获得上面的数字
return Integer.parseInt(tileNumber);
public void paintComponent(Graphics graphics) {
graphics.setFont(a);
graphics.setColor(Color.white);
super.paintComponent(graphics);
FontMetrics b=graphics.getFontMetrics(a);
int c=b.stringWidth(tileNumber);
int d=b.getAscent();
graphics.drawString(tileNumber,e,f);
import java.awt.*;
import java.awt.event.*;
import java.util.ArrayList;
import java.util.Random;
public class SlidingPuzzle extends JFrame implements MouseListener
{
public static void main(String[] args){
SlidingPuzzle frame=new SlidingPuzzle();
frame.TestPanel();
frame.setTitle("Numeric Sliding Puzzle");
frame.setVisible(true);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
PuzzleTile[] listenerPanel;
public void TestPanel(){
Container container=getContentPane();
ArrayListInteger myList=new ArrayListInteger();
int m;
if(!myList.contains(m))
myList.add(m);
else
i--;
listenerPanel[i]=new PuzzleTile(myList.get(i));
container.add(listenerPanel[i]);
listenerPanel[i].addMouseListener(this);
public void mousePressed(MouseEvent e){
int m=jb.getTitleNumber();
//依次判断每一个listenerPanel上下左右是否存在上面数字为0的listenerPanel
if(jb.equals(listenerPanel[0])){
if(listenerPanel[1].getTitleNumber()==0){
listenerPanel[0].setBackground(Color.white);
listenerPanel[0].setTitleNumber(0);
listenerPanel[1].setTitleNumber(m);
listenerPanel[1].setBackground(Color.darkGray);
}else if(jb.equals(listenerPanel[1])){
if(listenerPanel[0].getTitleNumber()==0){
listenerPanel[1].setBackground(Color.white);
listenerPanel[1].setTitleNumber(0);
listenerPanel[0].setTitleNumber(m);
listenerPanel[0].setBackground(Color.darkGray);
}else {
boolean b=true;//是否完成标记
if(listenerPanel[i].getTitleNumber()!=i)
b=false;
if(b==true){
int i=JOptionPane.showConfirmDialog(null, "would you paly agin?");
if(i==0){
Rectangle re=this.getBounds();
this.dispose();
SlidingPuzzle slidingPuzzle=new SlidingPuzzle();
slidingPuzzle.setBounds(re);
else if(i==1)
System.exit(0);
else ;
public void mouseReleased(MouseEvent e){}
public void mouseClicked(MouseEvent e){}
public void mouseEntered(MouseEvent e){}
public void mouseExited(MouseEvent e){}
如果运行过程什么问题追问或者hi
链接:
提取码: aizj 复制这段内容后打开百度网盘手机App,操作更方便哦? ?
若资源有问题欢迎追问~ ?
package temp;
import sun.misc.Sort;
/**
* @author zengjl
* @version 1.0
* @Des java几种基本排序方法
*/
* SortUtil:排序方法
* 关于对排序方法的选择：这告诉我们,什么时候用什么排序最好.当人们渴望先知道排在前面的是谁时,
* 我们用选择排序；当我们不断拿到新的数并想保持已有的数始终有序时,我们用插入排序；当给出的数
* 列已经比较有序,只需要小幅度的调整一下时,我们用冒泡排序.
public class SortUtil extends Sort {
* 插入排序法
* @param data
* @Des 插入排序(Insertion Sort)是,每次从数列中取一个还没有取出过的数,并按照大小关系插入到已经取出的数中使得已经取出的数仍然有序.
public int[] insertSort(int[] data) {
①./11页
int temp;
for (int i = 1; i data.length; i++) {
for (int j = i; (j 0) (data[j] data[j - 1]); j--) {
swap(data, j, j - 1);
return data;
* 冒泡排序法
* @return
* @Des 冒泡排序(Bubble Sort)分为若干趟进行,每一趟排序从前往后比较每两个相邻的元素的大小（所以呢一趟排序要比较n-1对位置相邻的数）并在
* 每次发现前面的那个数比紧接它后的数大时交换位置；进行足够多趟直到某一趟跑完后发现这一趟没有进行任何交换操作（最坏情况下要跑n-1趟,
* 这种情况在最小的数位于给定数列的最后面时发生）.事实上,在第一趟冒泡结束后,最后面那个数肯定是最大的了,于是第二次只需要对前面n-1
* 个数排序,这又将把这n-1个数中最小的数放到整个数列的倒数第二个位置.这样下去,冒泡排序第i趟结束后后面i个数都已经到位了,第i+1趟实
* 际上只考虑前n-i个数（需要的比较次数比前面所说的n-1要小）.这相当于用数学归纳法证明了冒泡排序的正确性
这使用递归的方式实现自己调用自己方法的循环语句.
题中最终目的是为了检索数组s中有没有"华"字.
return
name(i+1,
j,
index+1)+name(i,
j+1,
index+1);的目的就是为了循环；
其中
index+1)
是从
s
中以纵向方式抽取第
i
个【小组】中的第一个元素
来和
string
中的第
index
个元素比较（此时
=
index）；
而
name(i,
index+1);
中以横向方式抽取第
个【小组】中的第
j
个元素
这样便以"网格"的方式比对了s中的每一个元素.
public class BpDeep{
public double[][] layer;//神经网络各层节点
public double[][] layerErr;//神经网络各节点误差
public double[][][] layer_weight;//各层节点权重
public double[][][] layer_weight_delta;//各层节点权重动量
public double mobp;//动量系数
public double rate;//学习系数
public BpDeep(int[] layernum, double rate, double mobp){
this.mobp = mobp;
this.rate = rate;
layer = new double[layernum.length][];
layerErr = new double[layernum.length][];
layer_weight = new double[layernum.length][][];
layer_weight_delta = new double[layernum.length][][];
Random random = new Random();
for(int l=0;llayernum.length;l++){
layer[l]=new double[layernum[l]];
layerErr[l]=new double[layernum[l]];
if(l+1layernum.length){
layer_weight[l]=new double[layernum[l]+1][layernum[l+1]];
layer_weight_delta[l]=new double[layernum[l]+1][layernum[l+1]];
for(int j=0;jlayernum[l]+1;j++)
for(int i=0;ilayernum[l+1];i++)
layer_weight[l][j][i]=random.nextDouble();//随机初始化权重
//逐层向前计算输出
public double[] computeOut(double[] in){
for(int l=1;llayer.length;l++){
for(int j=0;jlayer[l].length;j++){
double z=layer_weight[l-1][layer[l-1].length][j];
for(int i=0;ilayer[l-1].length;i++){
layer[l-1][i]=l==1?in[i]:layer[l-1][i];
z+=layer_weight[l-1][i][j]*layer[l-1][i];
layer[l][j]=1/(1+Math.exp(-z));
return layer[layer.length-1];
//逐层反向计算误差并修改权重
public void updateWeight(double[] tar){
int l=layer.length-1;
for(int j=0;jlayerErr[l].length;j++)
layerErr[l][j]=layer[l][j]*(1-layer[l][j])*(tar[j]-layer[l][j]);
while(l--0){
for(int j=0;jlayerErr[l].length;j++){
double z = 0.0;
for(int i=0;ilayerErr[l+1].length;i++){
z=z+l0?layerErr[l+1][i]*layer_weight[l][j][i]:0;
layer_weight_delta[l][j][i]= mobp*layer_weight_delta[l][j][i]+rate*layerErr[l+1][i]*layer[l][j];//隐含层动量调整
layer_weight[l][j][i]+=layer_weight_delta[l][j][i];//隐含层权重调整
if(j==layerErr[l].length-1){
layer_weight_delta[l][j+1][i]= mobp*layer_weight_delta[l][j+1][i]+rate*layerErr[l+1][i];//截距动量调整
layer_weight[l][j+1][i]+=layer_weight_delta[l][j+1][i];//截距权重调整
layerErr[l][j]=z*layer[l][j]*(1-layer[l][j]);//记录误差
public void train(double[] in, double[] tar){
double[] out = computeOut(in);
updateWeight(tar);
以上就是土嘎嘎小编为大家整理的java频繁算法代码相关主题介绍,如果您觉得小编更新的文章只要能对粉丝们有用,就是我们最大的鼓励和动力,不要忘记讲本站分享给您身边的朋友哦！！