棋盘算法--窗体版

共设计了两个

1.

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;//http://blog.sina.com.cn/s/blog_5e94b1030100qjyv.html
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class chessBoard extends JFrame implements ActionListener {
	private int tr, tc, dr, dc, size;// 定义各成员变量
	int tile = 1, X, Y;
	float red, green, blue;
	JPanel centerPanel,northPanel;
	JButton[][] button;
	JTextField TrText, TcText, DrText, DcText, SizeText;
	JLabel TrLabel, TcLabel, DrLabel, DcLabel, SizeLabel,label;
	JButton OKButton;
	JButton CancelButton;
	chessBoard() {
		super("棋盘覆盖");
		init();
		this.setResizable(false);
		TrText.setEnabled(false);
		TcText.setEnabled(false);
		setVisible(true);
		OKButton.addActionListener(this);
		CancelButton.addActionListener(this);
		add(northPanel, BorderLayout.NORTH);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		add(centerPanel, BorderLayout.CENTER);
	}

	private void init() {
		centerPanel = new JPanel();
		northPanel = new JPanel();
		OKButton = new JButton("开始");
		CancelButton = new JButton("清除");
		TrText = new JTextField("0", 2);// 定义各组件
		TcText = new JTextField("0", 2);
		DrText = new JTextField("0", 2);
		DcText = new JTextField("0", 2);
		SizeText = new JTextField("4", 2);
		Toolkit tk = Toolkit.getDefaultToolkit();
		Dimension screen = tk.getScreenSize();
		X = screen.width;
		Y = screen.height;
		setBounds((X - 800) / 2, (Y - 650) / 2, 800, 650);// 设置窗口大小与位置
		TrLabel = new JLabel("起始方格坐标x:");
		TcLabel = new JLabel("起始方格坐标y:");
		DrLabel = new JLabel("特殊方格坐标x:");
		DcLabel = new JLabel("特殊方格坐标y:");
		SizeLabel = new JLabel("棋盘规模size:");
		label=new JLabel();
		northPanel.add(OKButton);// 添加各组件到窗体
		northPanel.add(CancelButton);
		northPanel.add(TrLabel);
		northPanel.add(TrText);
		northPanel.add(TcLabel);
		northPanel.add(TcText);
		northPanel.add(DrLabel);
		northPanel.add(DrText);
		northPanel.add(DcLabel);
		northPanel.add(DcText);
		northPanel.add(SizeLabel);
		northPanel.add(SizeText);
	}

	public void actionPerformed(ActionEvent e) {
		if (e.getSource() == OKButton) {
			tile=1;
			centerPanel.removeAll();
			centerPanel.updateUI();//更新用户界面
			int tR = Integer.parseInt(TrText.getText());
			int tC = Integer.parseInt(TcText.getText());
			int dR = Integer.parseInt(DrText.getText());
			int dC = Integer.parseInt(DcText.getText());
			int Size = 1;
			for (int i = 0; i < Integer.parseInt(SizeText.getText()); i++)
				Size *= 2;
			tr = tR;
			tc = tC;
			dr = dR;
			dc = dC;
			size = Size;
			gridLayout grid = new gridLayout();
			grid.ChessBoard(tr, tc, dr, dc, size);
			OKButton.setEnabled(false);
		}
		if (e.getSource() == CancelButton) {// 当你点“清除”按钮时的事件响应
			centerPanel.removeAll();
			centerPanel.updateUI();
			label.setText("<html><font size=‘5‘>你清除了前一个棋盘.......</font></html>");
			centerPanel.add(label);
			OKButton.setEnabled(true);
		}
	}

	class gridLayout {// 创建Size*size方格，初始化棋子方格
		public gridLayout() {
			centerPanel.setLayout(new GridLayout(size, size));
			button = new JButton[size][size];
			for (int i = 0; i < size; i++) {
				for (int j = 0; j < size; j++) {
					button[i][j] = new JButton();
					button[i][j].setEnabled(false);
					if (i == dr && j == dc) {
						button[i][j].setBackground(Color.black);
						button[i][j].setText("<html><font size=‘3‘ color=‘white‘>棋子</font></html>");
					}
					centerPanel.add(button[i][j]);
				}
			}
		}

		public void ChessBoard(int tr, int tc, int dr, int dc, int size) {// 算法实现
			if (size == 1) // 棋盘方格大小为1,说明递归到最里层
				return;
			int t = tile++;// 每次递增1
			Random rd = new Random();
			red = rd.nextFloat();
			green = rd.nextFloat();
			blue = rd.nextFloat();
			Color col = new Color(red, green, blue);
			int s = size / 2; // 棋盘中间的行、列号(相等的)
			// 检查特殊方块是否在左上角子棋盘中
			if (dr < tr + s && dc < tc + s) // 在
				ChessBoard(tr, tc, dr, dc, s);
			else // 不在，将该子棋盘右下角的方块视为特殊方块
			{
				button[tr + s - 1][tc + s - 1].setBackground(col);
				button[tr + s - 1][tc + s - 1].setText("<html><Font size=‘4‘,color=‘white‘>" +t+ "</Font></html>");
				ChessBoard(tr, tc, tr + s - 1, tc + s - 1, s);
			}

			// 检查特殊方块是否在右上角子棋盘中
			if (dr < tr + s && dc >= tc + s) // 在
				ChessBoard(tr, tc + s, dr, dc, s);
			else // 不在，将该子棋盘左下角的方块视为特殊方块
			{
				button[tr + s - 1][tc + s].setBackground(col);
				button[tr + s - 1][tc + s].setText("<html><Font size=‘4‘,color=‘white‘>" +t+ "</Font></html>");
				ChessBoard(tr, tc + s, tr + s - 1, tc + s, s);
			}

			// 检查特殊方块是否在左下角子棋盘中
			if (dr >= tr + s && dc < tc + s) // 在
				ChessBoard(tr + s, tc, dr, dc, s);
			else // 不在，将该子棋盘右上角的方块视为特殊方块
			{
				button[tr + s][tc + s - 1].setBackground(col);
				button[tr + s][tc + s - 1].setText("<html><Font size=‘4‘,color=‘white‘>" + t+ "</Font></html>");
				ChessBoard(tr + s, tc, tr + s, tc + s - 1, s);
			}

			// 检查特殊方块是否在右下角子棋盘中
			if (dr >= tr + s && dc >= tc + s) // 在
				ChessBoard(tr + s, tc + s, dr, dc, s);
			else // 不在，将该子棋盘左上角的方块视为特殊方块
			{
				button[tr + s][tc + s].setBackground(col);
				button[tr + s][tc + s].setText("<html><Font size=‘4‘,color=‘white‘>" + t+ "</Font></html>");
				ChessBoard(tr + s, tc + s, tr + s, tc + s, s);
			}
		}
	}

	public static void main(String[] args) {
		new chessBoard();
		Runtime.getRuntime().gc();// 清除数据垃圾
	}
}

　　2.

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JColorChooser;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class ChessBoard_demo2 extends JFrame implements ActionListener{
    ChessBoardPanel chessBoardPanel;
    JMenuBar jMenuBar;
    JMenu jMenu_color,jMenu;
    JMenuItem jMenuItem,jMenuItem2,jMenuItem3,jMenuItem0,jMenuItem6,jMenuItem1;
    static Color [] colors={Color.red,Color.green,Color.orange,Color.pink,Color.cyan};
    int size=3;
    int dr=0,dc=1;
    public ChessBoard_demo2(){
        setTitle("棋盘覆盖——静态显示");
        chessBoardPanel=new ChessBoardPanel(size,dr,dc,colors);
        jMenuBar=new JMenuBar();
        jMenu=new JMenu("菜单");
        jMenu_color=new JMenu("改变绘图颜色");
        jMenuItem1=new JMenuItem("左上L型颜色");
        jMenuItem2=new JMenuItem("左下L型颜色");
        jMenuItem3=new JMenuItem("右上L型颜色");
        jMenuItem6=new JMenuItem("右下L型颜色");
        jMenuItem0=new JMenuItem("初始覆盖点颜色");
        jMenuItem=new JMenuItem("设定");
        jMenu.setForeground(Color.blue);
        jMenu_color.setForeground(Color.blue);
        jMenu_color.add(jMenuItem0);
        jMenu_color.add(jMenuItem1);
        jMenu_color.add(jMenuItem2);
        jMenu_color.add(jMenuItem3);
        jMenu_color.add(jMenuItem6);
        jMenu.add(jMenuItem);
        jMenuBar.add(jMenu);
        jMenuBar.add(jMenu_color);
        jMenuItem.addActionListener(this);
        jMenuItem0.addActionListener(this);
        jMenuItem1.addActionListener(this);
        jMenuItem2.addActionListener(this);
        jMenuItem3.addActionListener(this);
        jMenuItem6.addActionListener(this);

        this.setJMenuBar(jMenuBar);
        add(chessBoardPanel);
        setSize(768+17,512+65);
        setLocation(300,50);
        setVisible(true);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        chessBoardPanel.board(0, 0, dr, dc, chessBoardPanel.size);
    }
    public static void main(String args[]){
        ChessBoard_demo2 chessBoard=new ChessBoard_demo2();
    }
    @Override
    public void actionPerformed(ActionEvent e) {
        // TODO Auto-generated method stub
        if (e.getSource()==jMenuItem) {
            System.out.println("xuanzhong");
            String regex="[ ]+";
            String arraysString[];
            String string=new JOptionPane().showInputDialog("请输入2的指数k，即2的k次方作为size\n(size理论值要小于int型表示范围/3)\n和初始覆盖点坐标(x，y),\n所有参数用空格隔开：");
            arraysString=string.split(regex);
            size=Integer.parseInt(arraysString[0]);
            dr=Integer.parseInt(arraysString[1]);
            dc=Integer.parseInt(arraysString[2]);
            System.out.println(size);
        }else if (e.getSource()==jMenuItem0) {
            colors[0]=JColorChooser.showDialog(this, "选择初始覆盖点颜色", Color.red);
        }else if (e.getSource()==jMenuItem1) {
            colors[1]=JColorChooser.showDialog(this, "选择左上L型颜色", Color.red);
        }else if (e.getSource()==jMenuItem2) {
            colors[2]=JColorChooser.showDialog(this, "选择左下L型颜色", Color.red);
        }else if (e.getSource()==jMenuItem3) {
            colors[3]=JColorChooser.showDialog(this, "选择右上L型颜色", Color.red);
        }else if (e.getSource()==jMenuItem6) {
            colors[4]=JColorChooser.showDialog(this, "选择右下L型颜色", Color.red);
        }
         remove(chessBoardPanel);
         chessBoardPanel = new ChessBoardPanel(size, dr, dc, colors);
         add(chessBoardPanel);
         chessBoardPanel.board(0, 0, dr, dc, chessBoardPanel.size);
         chessBoardPanel.repaint();
         setVisible(true);

    }
}

class ChessBoardPanel extends JPanel{

    int [][] chessmap;
    int size;
    int length;
    static int x=1;
    int dr,dc;
    Color [] colors;

    public ChessBoardPanel(int k,int dr,int dc, Color [] colors) {
        // TODO Auto-generated constructor stub
        size = (int) Math.pow(2, k);
        length = 512 / size;
        chessmap = new int[size][size];
        //initmap();
        this.colors=colors;
        this.dr=dr;
        this.dc=dc;
    }
    public void initmap(){
        chessmap = new int[size][size];
        for (int i = 0; i < size; i++) {
            for (int j = 0; j <size; j++) {
                chessmap[i][j]=0;
            }
        }
    }
    public void board(int mr,int mc,int dr,int dc,int size){
        if (size==1) {
            return;
        }
        int s=size/2;
        int d=x++;

        //左上
        if (dr<mr+s&&dc<mc+s) {
            board(mr, mc, dr, dc, s);
        }else {
            chessmap[mr+s-1][mc+s-1]=d;
            board(mr, mc, mr+s-1, mc+s-1, s);
        }        

        //右上
        if (dr<mr+s&&dc>=mc+s) {
            board(mr, mc+s, dr, dc, s);
        }else {
            chessmap[mr+s-1][mc+s]=d;
            board(mr, mc+s, mr+s-1, mc+s, s);
        }

        //左下
        if (dr>=mr+s&&dc<mc+s) {
            board(mr+s, mc, dr, dc, s);
        }else {
            chessmap[mr+s][mc+s-1]=d;
            board(mr+s, mc, mr+s, mc+s-1, s);
        }

        //右下
        if (dr>=mr+s&&dc>=mc+s) {
            board(mr+s, mc+s, dr, dc, s);
        }else {
            chessmap[mr+s][mc+s]=d;
            board(mr+s, mc+s, mr+s, mc+s, s);
        }
        //System.out.println(String.valueOf(color_flag));
    }
//    public  void  printTheChess() {
//        for (int i = 0; i < size; i++) {
//            for (int j = 0; j < size; j++) {
//                System.out.print(chessmap[i][j]+"  ");
//            }
//            System.out.println();
//        }
//    }

    public void paint(Graphics g){
        //System.out.println("paint");
//        printTheChess();

        g.setColor(Color.white);
        g.fillRect(0, 0, 512, 512);
        g.setColor(Color.lightGray);
        g.fillRect(512, 0, 256, 512);
        g.setColor(Color.black);
        //画边框
        g.drawLine(0+1, 0+1, 512, 0+1);
        g.drawLine(0+1, 0+1, 0+1, 512);
        g.drawLine(512, 0, 512, 512);
        g.drawLine(0, 512, 512, 512);
        //最右侧分割线
        g.drawLine(760, 0, 760, 512);

        int sub=(int)(length*0.1);

        for (int i = 0; i < size-1; i++) {
            for (int j = 0; j <size-1; j++) {
                if (chessmap[i][j]==0) {//如果该点是初始覆盖点，画出该点，并画出它右下角的L型
                    g.setColor(colors[0]);
                    g.fill3DRect(j*length, i*length, length, length,true);
                    if(chessmap[i+1][j+1]==chessmap[i+1][j]&&chessmap[i+1][j+1]==chessmap[i][j+1]){
                        g.setColor(colors[4]);
                        g.fill3DRect((j+1)*length, (i+1)*length, length, length,true);
                        g.fill3DRect((j+1)*length, i*length, length, length,true);
                        g.fill3DRect(j*length, (i+1)*length, length, length,true);
                        //去掉l图形中的划分
                        g.fillRect((j+1)*length, i*length, length-1, length+sub);
                        g.fillRect(j*length, (i+1)*length, length+sub, length-1);
                        /*//写上标号
                        g.setColor(Color.red);
                        g.drawString("A",(int)((j+1+0.5)*length), (int)((i+1+0.5)*length));*/
                    }
                }else if (chessmap[i][j]==chessmap[i+1][j]&&chessmap[i][j]==chessmap[i][j+1]) {//画出左上L型
                    g.setColor(colors[1]);
                    g.fill3DRect(j*length, i*length, length, length,true);
                    g.fill3DRect((j+1)*length, i*length, length, length,true);
                    g.fill3DRect(j*length, (i+1)*length, length, length,true);
                    //去掉l图形中的划分
                    g.fillRect(j*length, i*length, length+sub, length);
                    g.fillRect(j*length, i*length, length, length+sub);

                    /*//写上标号
                    g.setColor(Color.black);
                    g.drawString("B",(int)((j+0.5)*length), (int)((i+0.5)*length));*/
                }else if (chessmap[i][j]==chessmap[i+1][j]&&chessmap[i][j]==chessmap[i+1][j+1]) {//画出左下L型
                    g.setColor(colors[2]);
                    g.fill3DRect(j*length, i*length, length, length,true);
                    g.fill3DRect((j+1)*length, (i+1)*length, length, length,true);
                    g.fill3DRect(j*length, (i+1)*length, length, length,true);
                    //去掉l图形中的划分
                    g.fillRect(j*length, (i+1)*length-sub, length, length);
                    g.fillRect(j*length+sub, (i+1)*length, length, length);
                    /*//写上标号
                    g.setColor(Color.blue);
                    g.drawString("C",(int)((j+0.5)*length), (int)((i+1+0.5)*length));*/
                }else if (chessmap[i][j]==chessmap[i][j+1]&&chessmap[i][j]==chessmap[i+1][j+1]) {//画出右上L型
                    g.setColor(colors[3]);
                    g.fill3DRect(j*length, i*length, length, length,true);
                    g.fill3DRect((j+1)*length, i*length, length, length,true);
                    g.fill3DRect((j+1)*length, (i+1)*length, length, length,true);
                    //去掉l图形中的划分
                    g.fillRect((j+1)*length-sub, i*length, length-1, length-1);
                    g.fillRect((j+1)*length, i*length+sub, length-1, length-1);
                    /*//写上标号
                    g.setColor(Color.green);
                    g.drawString("D",(int)((j+1+0.5)*length), (int)((i+0.5)*length));*/
                    j++;//可以跳过下个扫描点
                }else if (chessmap[i+1][j]==chessmap[i][j+1]&&chessmap[i+1][j]==chessmap[i+1][j+1]) {//画出右下L型
                    g.setColor(colors[4]);
                    g.fill3DRect((j+1)*length, (i+1)*length, length, length,true);
                    g.fill3DRect((j+1)*length, i*length, length, length,true);
                    g.fill3DRect(j*length, (i+1)*length, length, length,true);
                    //去掉l图形中的划分
                    g.fillRect((j+1)*length, i*length, length-1, length+sub);
                    g.fillRect(j*length, (i+1)*length, length+sub, length-1);
                    /*//写上标号
                    g.setColor(Color.red);
                    g.drawString("A",(int)((j+1+0.5)*length), (int)((i+1+0.5)*length));*/
                    j++;//可以跳过下个扫描点
                }
            }
        }
        //扫描最后一行是否有初始覆盖点
        for (int i = 0; i < size; i++) {
            if(chessmap[size-1][i]==0){
                g.setColor(colors[0]);
                g.fill3DRect(i*length, (size-1)*length, length, length,true);
            }
        }
        //扫描最后一列是否有初始覆盖点
        for (int i = 0; i < size; i++) {
            if(chessmap[i][size-1]==0){
                g.setColor(colors[0]);
                g.fill3DRect((size-1)*length, i*length, length, length,true);
            }
        }
        //画提示信息
        g.setColor(Color.blue);
        x=512+2;
        String sizeString="当前规模是"+String.valueOf(size)+"×"+String.valueOf(size);
        String sizeString1="初始覆盖点坐标： ("+String.valueOf(dr)+","+String.valueOf(dc)+")";
        g.drawString("这是棋盘覆盖的静态显示通过递归分治算法：", x, 60);
        g.drawString("      红色区域表示初始覆盖点,绿色区域表示左", x, 90);
        g.drawString("上L型,粉红色区域表示右上L型,橘黄色区域表", x, 120);
        g.drawString("示左下L型,青色区域表示左上L型。(默认)", x, 150);
        g.setColor(new Color(111,1,1));
        g.drawString(sizeString, x, 200);
        g.drawString(sizeString1, x, 250);
        g.setColor(Color.red);
        g.drawString("      注意当规模大于512×512之后,图形将无",x,300);
        g.drawString("法显示出来,但后台程序仍可以继续运行！",x,330);
    }

}

　　

时间： 2024-10-07 21:16:01

棋盘算法--窗体版的相关文章

MapReduce原理——PageRank算法Java版

Page Rank就是MapReduce的来源,下文是一个简单的计算PageRank的示例. import java.text.DecimalFormat; /**  * Created by jinsong.sun on 2014/7/15.  */ public class PageRankCaculator {     public static void main(String[] args) {         double[][] g = calcG(genS(), 0.85);  

查找质数的算法优化版

package com.my.testPrimeNumber; import java.util.ArrayList; import java.util.List; public class PrimeNumber { public boolean isPrimeNum(int n) { //第一步过滤偶数,使范围减少一半 if(n==2) { return true; } else if(n%2==0) { return false; } //处理奇数,一个素数中不会有偶数因子,但是他的平方根

扎金花大小比较算法(Java版)

注:以下算法说明仅限一副牌(不包含大小王)的情况 1.扎金花规则说明(大家都懂的,这里做简单描述): 1)玩家每人3张牌: 2)牌面大小2.3.4.5.6.7.8.9.10(用T表示),J.Q.K.A,大小依次递增: 3)牌的花色有黑桃(用H表示).红心(用X表示).梅花(用M表示).方块(用F表示),大小依次递减: 4)牌有豹子(3张牌数字大小相同).同花顺.同花(此种未实现,有兴趣的玩家可以自己加上,或者欢迎和我交流).顺子.对子.散牌几种类型,大小依次递减: 5)玩家先比牌的类型,如先按照

排序算法Java版，以及各自的复杂度，以及由堆排序产生的top K问题

常用的排序算法包括: 冒泡排序:每次在无序队列里将相邻两个数依次进行比较,将小数调换到前面, 逐次比较,直至将最大的数移到最后.最将剩下的N-1个数继续比较,将次大数移至倒数第二.依此规律,直至比较结束.时间复杂度:O(n^2) 选择排序:每次在无序队列中"选择"出最大值,放到有序队列的最后,并从无序队列中去除该值(具体实现略有区别).时间复杂度:O(n^2) 直接插入排序:始终定义第一个元素为有序的,将元素逐个插入到有序排列之中,其特点是要不断的 移动数据,空出一个适当的位置,把待插

单向链表反转算法——递归版和迭代版

最近在做笔试题时,遇到一道编程题:单向链表反转算法.一时紧张,没写出来就提前交卷了,然而交完卷就想出来了... 最初想出来的是递归版,遗憾的是没能做到尾递归,后来又琢磨出了迭代版.后来用实际编译运行测试了一遍,能正常运行. 递归版的灵感来源于<Haskell 趣学指南>中非常简洁的快速排序算法的实现,其思想是将单向链表分割头部和尾部.其中头部指是链表的第一个节点,尾部是指除去第一个节点后的子链表.通过递归的方法,将子链表继续分割成头部和尾部,直至尾部指剩下一个节点,无法继续分割,然后将头部和尾

马踏棋盘算法递归+回溯法实现 C语言

r为矩阵的行,c为矩阵的列 将结果输出到当前目录下的results.txt(需要提前建好). 结果将给出:1.是否存在路径使马可以按要求走遍所有的方格: 2.解的总数: 3.程序执行的时间: #include<stdio.h> #include <stdlib.h> #include <time.h> #define r 2 #define c 4 int flag[r][c]={0};//存放马跳路径的二维数组 int arr[r][c]={0}; int x[8]=

ADO.NET学习系列（四）---窗体版的登录小程序

1.需求分析:做一个登录的小程序,基于Winform的窗体小程序.基本要求:登录成功:弹框显示登录成功,登录失败就弹框显示失败. 扩展功能:登录次数超过3次,就”锁定“用户,提示登录错误次数过多,不能登录.用户点击之后,就退出程序:登录成功,就把错误字段清零. 这里我们在数据库表中,加一个错误字段,类型为int,初始值设置为0. 相信;这个小程序对于大家来说,是超级简单的.我这里也是来熟悉一下,把基础知识再巩固一下. 2.用到的技术:ADO.NET,存储过程. 3.项目实现: 首先我们新建一个窗

snowflake算法(java版)

 转自:http://www.cnblogs.com/haoxinyue/p/5208136.html 1. 数据库自增长序列或字段 最常见的方式.利用数据库,全数据库唯一. 优点: 1)简单,代码方便,性能可以接受. 2)数字ID天然排序,对分页或者需要排序的结果很有帮助. 缺点: 1)不同数据库语法和实现不同,数据库迁移的时候或多数据库版本支持的时候需要处理. 2)在单个数据库或读写分离或一主多从的情况下,只有一个主库可以生成.有单点故障的风险. 3)在性能达不到要求的情况下,比较难于扩展.

常见的排序算法--java版

个人总结的常见的排序算法 public class Sort { // 1.冒泡:稳定,最优O(n) 最差O(n^2) 平均O(n^2) private static void sort1(int[] arr) { for (int i = 0; i < arr.length; i++) { for (int j = 0; j < arr.length - 1; j++) { if (arr[j] > arr[j + 1]) { int tmp = arr[j]; arr[j] = ar