Java的算法题的实现

扑克洗牌

实体类构建 Card 表示一张张的扑克牌

public class Card {

    private String num;//扑克牌的数字
    private String  suit;  //花色
  .......提供构造方法，get，set方法，toString方法
    } 

封装实体类 DeskOfCards。做牌的初始化，牌的清洗，以及输出

package entity;

import java.util.Random;

public class DeskOfCards {

    private Card card [];//表示一副张扑克牌的数组。52张。

    //初始化的方法

    public void initCards(){
        String num[] = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        String suit[] = {"方块","梅花","红桃","黑桃"};

        card = new Card[52];//指定数组存放Card对象的个数为52

        for (int i =0;i<52;i++){
            //0-12   num[i%13]--->0-12  //0-12  uit[i/13]  --> 0
            card[i] = new Card(num[i%13],suit[i/13]);

        }
        /*Card{num='A', suit='方块'}  初始化的结果
        Card{num='2', suit='方块'}
        Card{num='3', suit='方块'}*/
        for (Card card1 : card) {
            System.out.println(card1);
        }
    }

    //洗牌的实现

    public void shuffleCard(){
        Random random = new Random();

        for (int i =0;i<52;i++){
            int j = random.nextInt(52);//生成随机数
            Card t = card[i];//临时变量
            card[i] =card[j]; //随机更换数组中两个元素的位置
            card[j] =t;
        }

        for (Card card1 : card) {
            System.out.println(card1);
        }

    }

    //发布牌 打印数组中的元素
    public void dealCard(){

        for (int i=0;i<52;i++){
            System.out.println(card[i]);
        }
    }
}

测试

3个方法有依次调用的顺序
@org.junit.Test
    public void  t1(){

        DeskOfCards deskOfCards = new DeskOfCards();
        deskOfCards.initCards();//初始化52张牌
        System.out.println("-----------");
        deskOfCards.shuffleCard();//洗牌
        System.out.println("=========");
        deskOfCards.dealCard();//发牌

    }

输出结果

Card{num='Q', suit='梅花'}
Card{num='9', suit='梅花'}
Card{num='A', suit='黑桃'}
Card{num='6', suit='红桃'}
Card{num='8', suit='黑桃'}
Card{num='Q', suit='黑桃'}
......

递归&循环

都是按照预先设计好的推断实现某一个值求取；
在这里循环要更注重过程，而递归偏结果一点

求n的阶乘

  //求n的阶乘
    public static int factorial( int n ){

        if (n==1) {
            return 1;
        }else {
          return   n*factorial(n-1);
        }
    }

累加和

  //求1-100累加和
    public static int sum(int n) {


        if (n==1){
            return 1;
        }else {
            return n+sum(n-1);
        }
    }

检查一个数组是否是有序1 2 3

// 检查一个数组是否是有序1 2 3
    public static boolean checkSort(int[] a) {
        boolean flag = false;// 默认不是有序的
        for (int i = 0; i < a.length - 1; i++) {
            if (a[i] > a[i + 1]) {
                // 说明不是有序的
                flag = false;
                break;
            } else {
                flag = true;
            }
        }
        return flag;
    }

测试代码
public static void main(String[] args) {

       // System.out.println( sum(100));

        int a []={1,2,4};
        int b [] = {1,3,5,7};
        int[] ints = mergeArray(a, b);
        for (int anInt : ints) {
            System.out.println(anInt);
        }

    }

合并数组

// 合并数组
    public static int[] mergeArray(int[] a, int[] b) {
        int result[] = new int[a.length + b.length];
        if (checkSort(a) && checkSort(b)) {
            // 说明ab数组都是有序的数组
            // 定义两个游标
            int i = 0, j = 0, k = 0;
            while (i < a.length && j < b.length) {
                if (a[i] <= b[j]) {
                    result[k++] = a[i++];
                } else {
                    result[k++] = b[j++];
                }
            }
            while (i < a.length) {
                // 说明a数组还有剩余
                result[k++] = a[i++];
            }
            while (j < b.length) {
                result[k++] = b[j++];
            }
        }
        return result;
    }