常用排序 java代码实现

排序 java代码实现

快速排序

public class QuickRem {
    public static void main(String[] args) {
        int[] data={9,-15,21,23,-30,-49,21,30,30};
        System.out.println("排序之前："+java.util.Arrays.toString (data));
        quickSort(data);
        System.out.println("排序之后："+java.util.Arrays.toString (data));
    }
    private static void quickSort(int[] data){
        if (data.length !=0 ){
            subSort(data,0,data.length-1);
        }
    }

    private static void subSort(int[] data, int start /*0*/, int end/*最后一个索引*/) {
        if (start<end){
            int base=data[start];
            int i=start;
            int j=end+1;
            while(true){
                while(i < end && data[++i] <=base);   
                System.out.println("排序之后："+java.util.Arrays.toString (data)+i+"  "+j);
                while(j>start && data[--j] >=base);   
                if (i<j) {
                    swap(data, i, j);
                    System.out.println("排序之后：" + java.util.Arrays.toString(data)+i+"  "+j);
                }
                else
                    break;
            }
            swap(data,start,j);
            subSort(data,start,j-1);
            subSort(data,j+1,end);
        }

    }
    private static void swap(int[] data,int i,int j){
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }
}

归并排序

public class MergeSort {
    public static void main(String[] args) {
        int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };

        System.out.println(" 排 序 之 前 ： \n" + java.util.Arrays.toString(data));

        mergeSort(data);

        System.out.println(" 排 序 之 后 ： \n" + java.util.Arrays.toString(data));
    }
    public static void mergeSort(int[] data) {
        // 归并排序
         sort(data, 0, data.length - 1);
    }
    // 将索引从 left 到 right 范围的数组元素进行归并排序
    private static void sort(int[] data,int left,int right){
        if (left<right){
            //找出中间索引
            int center = (left+right)/2;
            sort(data,left,center);
            sort(data,center+1,right);
            //合并
            merge(data,left,center,right);
        }
    }
    // 将两个数组进行归并，归并前两个数组已经有序，归并后依然有序
    private static void merge(int[] data, int left, int center, int right) {
        int[] tempArr = new int[data.length];
        int mid = center+1;
        int third = left;
        int temp = left;
        while(left <= center && mid <= right){
            if (data[left] - data[mid] <= 0) {
                tempArr[third++] = data[left++];
            } else {
                tempArr[third++] = data[mid++];
            }
        }
        while(mid <= right){
            tempArr[third++] = data[mid++];
        }
        while(left <= center){
            tempArr[third] = data[left++];
        }
        while(temp <= right){
            data[temp] = tempArr[temp++];
        }
    }

}

冒泡排序

public class BubbleSort {
    public static void main(String[] args) {
        int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };
        System.out.println(" 排 序 之 前 ： \n" + java.util.Arrays.toString(data));
        bubbleSort(data);
        System.out.println(" 排 序 之 后 ： \n" + java.util.Arrays.toString(data));
    }

    private static void bubbleSort(int[] data) {
        System.out.println("开始排序");
        for (int i = 0; i < data.length; i++) {
            boolean flag = false;
            for (int j = 0; j < data.length - 1 - i; j++) {
                if (data[j] > data[j+1]){
                    int temp  = data[j+1];
                    data[j+1] = data[j];
                    data[j] = temp;
                    flag = true;
                }
            }
            System.out.println(java.util.Arrays.toString(data));
            if (!flag)
                break;
        }
    }

二叉树

public class BinaryTree {
    //根节点
    private TreeNode root;
    public TreeNode getRoot(){
        return root;
    }
    /*
    * 插入操作
    * */
    public void insert(int value){
        TreeNode newNode = new TreeNode(value);
        if (root == null){
            root=newNode;
            root.setLefTreeNode(null);
            root.setRightNode(null);
        }else {
            TreeNode currentNode = root;
            TreeNode parentNode;
            while(true){
                parentNode = currentNode;
                //往右放
                if (newNode.getValue() >currentNode.getValue()){
                    currentNode = currentNode.getRightNode();
                    if (currentNode == null){
                        parentNode.setRightNode(newNode);
                        return;
                    }
                }else {
                    //往左放
                    currentNode = currentNode.getLefTreeNode();
                    if (currentNode == null){
                        parentNode.setLefTreeNode(newNode);
                        return;
                    }
                }
            }
        }
    }
    /*
    *
    * 查找
    * */
    public TreeNode find(int key){
        TreeNode currentNode = root;
        if (currentNode!=null){
            while (currentNode.getValue() !=key){
                if (currentNode.getValue()>key){
                    currentNode = currentNode.getLefTreeNode();
                }else {
                    currentNode = currentNode.getRightNode();
                }
                if (currentNode==null){
                    return null;
                }
            }
            if (currentNode.isDelete()){
                return null;
            }else{
                return currentNode;
            }
        }else {
            return null;
        }
    }
    /*
    * 中序遍历
    *
    * */
    public void inOrder(TreeNode treeNode){
        if (treeNode!=null && treeNode.isDelete() ==false){
            inOrder(treeNode.getLefTreeNode());
            System.out.println("--"+treeNode.getValue());
            inOrder(treeNode.getRightNode());
        }
    }

}

测试方法

public class Main {
    public static void main(String[] args) {
        BinaryTree tree = new BinaryTree();
        tree.insert(10);
        tree.insert(40);
        tree.insert(20);
        tree.insert(3);
        tree.insert(49);
        tree.insert(43);
        tree.insert(123);
        System.out.println("root"+tree.getRoot().getValue());
        //排序测试
        tree.inOrder(tree.getRoot());
        //查找测试
        if (tree.find(10) !=null){
            System.out.println("找到了");
        }else {
            System.out.println("没找到");
        }
        //删除测试
        tree.find(40).setDelete(true);
        if (tree.find(40)!= null){
            System.out.println("找到了");
        }else{
            System.out.println("没找到");
        }
    }
}

二分查找法

/*
    * E - Element (在集合中使用，因为集合中存放的是元素)
    * T - Type（Java 类）
    * K - Key（键）
    * V - Value（值）
    * N - Number（数值类型）
    * ？ -  表示不确定的java类型
    * S、U、V  - 2nd、3rd、4th types*/

    public static <E extends Comparable<E>> int binarySearch(E[] array,int from,int to,E key){
        if (from<0 || to < 0){
            throw new IllegalArgumentException("寻找的参数必须大于0");
        }
        if (from <= to ){
            int middle = (from >>>1) +(to >>>1); //右移即除2
            E temp =array[middle];
            if (temp.compareTo(key) > 0 ){
                to = middle -1;
            }else if (temp.compareTo(key) < 0){
                from = middle +1;
            }else{
                return middle;
            }
        }
        return binarySearch(array,from,to,key);
    }