java中简单算法

冒号排序:

• 使一个无序的数组变为有序的

    //冒号排序
    public static int[] colonSort(int[] sort){
        //标记
        boolean mark=false;
        //遍历数组
        for (int i = 0; i < sort.length; i++) {
            //每遍历一个数字则再次遍历一个数组查找有没有比当前数字大小的有则交换
            //这里-1是为了防止数组下标越界,-i是为了不必在进行判断没有必要的
            for (int j = 0; j < sort.length-1-i; j++) {
                if (sort[j]>sort[j+1]){
                    int temp= sort[j];
                    sort[j]=sort[j+1];
                    sort[j+1]=temp;
                    //用来进行标记
                    mark=true;
                }
            }
            //如果mark为false的话则证明数组已经排好序了!
            if (!mark){
                break;
            }
        }
        return sort;
    }

二分查找

• 在一个int数组中查找一个相对应的值进行快速查找！
• 如果没有则返回-1
• 注意:在进行二分查找之前数组一定是排好顺的!

    //二分查找
    public static int binarySearch(int[] binarySearch,int value){
        //最低的位置
        int low=0;
        //最高的位置
        int high=binarySearch.length;

        while (low<=high){
            //取中间值
            int middle=(low+high)/2;

            //如果查找的值为中间值则之间返回其下标
            if (value==binarySearch[middle]){
                return middle;
            }else if (value>binarySearch[middle]){
                low=middle+1;
            }else if (value<binarySearch[middle]){
                high=middle-1;
            }
        }
        return -1;
    }

直接插入排序:

使一个无序的数组变为有序的, 

    /**
     * 直接插入排序
     * 第1此循环结果为:[1, 14, 28, 2, 634, 3, 1, 45, 78, 45]
     * 第2此循环结果为:[1, 14, 28, 2, 634, 3, 1, 45, 78, 45]
     * 第3此循环结果为:[1, 2, 14, 28, 634, 3, 1, 45, 78, 45]
     * 第4此循环结果为:[1, 2, 14, 28, 634, 3, 1, 45, 78, 45]
     * 第5此循环结果为:[1, 2, 3, 14, 28, 634, 1, 45, 78, 45]
     * 第6此循环结果为:[1, 1, 2, 3, 14, 28, 634, 45, 78, 45]
     * 第7此循环结果为:[1, 1, 2, 3, 14, 28, 45, 634, 78, 45]
     * 第8此循环结果为:[1, 1, 2, 3, 14, 28, 45, 78, 634, 45]
     * 第9此循环结果为:[1, 1, 2, 3, 14, 28, 45, 45, 78, 634]
     * @param sortArray
     * @return
     */
    public static int[] directInsertionSort(int[] sortArray){
        
        //循环遍历数组
        for (int i = 1; i < sortArray.length; i++) {
            //动态获取数组从下标1开始的值
            int num=sortArray[i];

            int j;
            //从第零个数进行比较前一个数,如果大则交换
            for (j=i-1;j>=0;j--) {
                if (sortArray[j]>num){
                    //直接覆盖
                    sortArray[j+1]=sortArray[j];
                }else {
                    break;
                }
            }
            //判断是否交换过,如果交换过则赋值
            if (sortArray[j+1]!=num){
                sortArray[j+1]=num;
            }

            System.out.println("第"+i+"此循环结果为:"+Arrays.toString(sortArray));
        }
        return sortArray;
    }

特点:数据量小的时候排序很快,但是多了就较慢了

链表:

进行数据存储,增删块查询慢!

package Aigorithm;

import java.util.StringJoiner;

//链表
public class LinkedListImpl <T> implements java.io.Serializable{

    //第一个节点
    private transient Node first;
    //最后一个节点
    private transient Node last;
    //链表大小
    private transient Integer size=0;

    public LinkedListImpl() {

    }

    //增加元素
    public Boolean add(T value){
        if (null == value){
            throw new NullPointerException();
        }
        try {
            if (first==null){
                Node node = new Node();
                node.data=value;
                first=node;
                last=node;
                size++;
            }else {
                Node node = new Node();
                node.data=value;
                last.next=node;
                last=node;
                size++;
            }
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    //删除元素
    public void remove(T value) throws Exception {
        if (null==value){
            throw new NullPointerException();
        }
        if (first.data==value){
            first=first.next;
            size--;
        }else {
            Node current=first;
            for (int i = 0; i < size; i++) {
                if (current.next.data==value) {
                    if (current.next==last){
                        last=current;
                    }
                    current.next=current.next.next;
                    size--;
                    return;
                }
                current=first.next;
            }
        }
    }

    //判断下一个节点是否为空
    public boolean isNull(Node node){
        return node.next == null;
    }

    private class Node{
        //下一个节点
        Node next;
        //当前节点的值
        T data;
    }


    public Node getFirst() {
        return first;
    }

    public void setFirst(Node first) {
        this.first = first;
    }

    public Node getLast() {
        return last;
    }

    public void setLast(Node last) {
        this.last = last;
    }

    public Integer getSize() {
        return size;
    }

    public void setSize(Integer size) {
        this.size = size;
    }

    @Override
    public String toString() {
        StringJoiner stringJoiner = new StringJoiner(",");
        Node node=first;
        for (int i = 0; i < size; i++) {
            stringJoiner.add("{data:"+node.data+",next:"+node.next+"}");
            node=node.next;
        }
        return "{"+stringJoiner.toString()+"}";
    }
}

二叉树:

树是一种非常重要的非线性数据结构,直观的看他是数据元素(在树中称为节点)按分支关系组织起来的结构。二叉树是每个节点最多有两个节点组成的有序树,根节点称为树根,通常子树被称为左子树与右子树！最后一个节点被称为叶子节点(叶节点)！

规则:

• 选择一个元素为根节点如果元素大于根节点放在右子树,如果小于则放在左子树(左边元素一定小于右边的)
• 最后按照中序遍历方式进行输出,则可以得到排序的结果

package Aigorithm;

import java.util.ArrayList;
import java.util.List;
import java.util.StringJoiner;

//二叉树
public class BinaryTree<T> implements java.io.Serializable {

    //根节点
    private Node root;

    private final StringJoiner stringBuilder = new StringJoiner(",");

    private int size = 0;
    
    //增加
    public boolean add(T value) {
        if (null == value) {
            throw new NullPointerException();
        }
        try {
            if (null == root) {
                root = new Node(value, null, null);
                size++;
                return true;
            } else {
                root.addNode(value);
                size++;
            }
        } catch (Exception e) {
            return false;
        }
        return true;
    }
    
    //输出节点
    @Override
    public String toString() {
        return root.toString();
    }
    
    public int getSize() {
        return size;
    }

    //节点对象
    private class Node {
        //数据
        private T data;
        //左节点
        private Node left;
        //右节点
        private Node right;


        public Node(T data, Node left, Node right) {
            this.data = data;
            this.left = left;
            this.right = right;
        }

        //存储Node
        public void addNode(T value) {
            if (this.data.hashCode() > value.hashCode()) {
                if (null == this.left) {
                    this.left = new Node(value, null, null);
                } else {
                    this.left.addNode(value);
                }
            } else {
                if (null == this.right) {
                    this.right = new Node(value, null, null);
                } else {
                    this.right.addNode(value);
                }
            }
        }

        //按照中序的遍历方式
        @Override
        public String toString() {
            if (null != this.left) {
                String s = this.left.toString();
            }
            stringBuilder.add("{" + this.data + "}");
            if (null != this.right) {
                String s = this.right.toString();
            }
            System.gc();
            return "{" + stringBuilder.toString() + "}";
        }
    }

}

正在跟新以下问题...

字符串匹配问题:

• 有一个字符串 str1="今天晚饭吃了吗 如果还没吃一起吗?" 与字符串 str2="吃了吗"
• 现在要判断str1是否包含有str2，如果存在就返回第一次出现的位置,如果没有则返回-1
• 要求用最快的速度来完成匹配
• 你的思路是什么?

• 暴力匹配[简单,效率低]
• KMP算法 《部分匹配表》

汉诺塔游戏:

请完成汉诺塔游戏的代码，规定:

• 将A塔的所有圆盘移动到C塔
• 移动时小圆盘上不能放大圆盘
• 三根柱子之间一次只能放一个小圆盘

•  分治算法

八皇后:

•  在八乘八的方格上放八个皇后其使彼此不能互相攻击
• 任意两个皇后不能放在同一行,同一列,同一条横线上
• 问有多少种摆法？

• 92种 分治算法 

马踏棋盘：

•  将马随机放在国际象棋8*8的方格里按马走日字的规则
• 要求每个方格只能进入一次怎样才能走便棋盘上的64个方格?

• 使用图的深度优化遍历算法(DFS)+贪心算法优化