排序

快速排序

package com.zkh.sort;

/**
 * 快速排序算法：
 *  找一个基数
 *  使其左边的值都不大于这个基数
 *  右边的值都都不小于这个基数
 */
public class QuitSort {
    //快速排序


    public static void main(String[] args) {
        int array[] = {10, 5, 7, 3, 9, 2};
        System.out.println("排序之前：");
        for(int a : array){
            System.out.print(a + " ");
        }
        quitSort(array, 0, array.length-1);
        System.out.println("排序之后：");
        for(int a : array){
            System.out.print(a + " ");
        }
    }

    public static void quitSort(int[] array, int _left, int _right){

        int left = _left;
        int right = _right;
        if (left < right) {
            int temp = array[left];
            while (left != right) {

                while (array[right] >= temp && left < right) //从左往右扫描，找到第一个比基准元素小的元素
                    right--;
                array[left] = array[right]; //然后将这种元素array[right]与array[left]进行交换

                while(array[left] <= temp && left < right)
                    left++;
                array[right] = array[left];
            }
            array[right] = temp;
            quitSort(array, _left, left - 1);
            quitSort(array, right + 1, _right);
        }
    }
}

循环二分法及递归二分法查询

package com.zkh.sort;

public class BinarySearch {
    //循环二分法查找
    public static int binarySearch(int[] arr, int x) {

        int low = 0;
        int high = arr.length-1;
        while (low <= high) {
            int middle = (high + low) / 2;
            if (x == arr[middle]) {
                return middle;
            }else if (x < arr[middle]) {
                high = middle - 1;
            }else {
                low = middle + 1;
            }
        }
        return -1;
    }
    //递归二分法查找
    public static int binarySearch(int[] arr, int data, int begin, int end) {
        int middle = (begin + end) / 2;
        if (data > arr[end] || data < arr[begin] || begin > end) {
            return -1;
        }
        if (data < arr[middle]) {
            return binarySearch(arr, data, begin, middle - 1);
        }else if(data > arr[middle]){
            return binarySearch(arr, data, middle + 1, end);
        }
        return middle;
    }

    public static void main(String[] args) {
        //数组的初始化
        //第一种静态初始化
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        //第二种动态初始化
        int [] arr2 = new int[5];

        for(int i = 0; i < 5; i++){
            arr2[i] = i;
        }
        //System.out.println(arr2[1]);
        //第三种使用new关键字创建数组,这里new不需要指定长度，数组长度由其后的初始化操作来确定
        int[] arr3 = new int[]{1,2,34};

        System.out.println(binarySearch(arr, 3));
        System.out.println(binarySearch(arr2, 3, 0, arr2.length -1 ));
    }
}

匹配大括号、中括号、小括号

package com.zkh.arrtest;

import java.util.Scanner;


public class Check {
    private int maxSize = 0;
    private static int top = -1;
    private static char[] chars;
    public Check(int maxSize){
        this.maxSize = maxSize;
        top = -1;
        chars = new char[maxSize];
    }
    public static void main(String[] args) {
        Check check = new Check(20);
        //接收用户输入
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        char[] s = str.toCharArray();
        int length = str.length();
        if(length % 2 != 0){
            System.out.println("配对失败");
            return;
        }
        for(int i = 0; i < length; i++){
            if(s[i] == '{' || s[i] == '[' || s[i] == '('){
                pushOne(s[i]);
            }
            if(s[i] == '}' || s[i] == ']' || s[i] == ')'){
                char c = topOne();
                if(s[i] == '}' && c == '{' || s[i] == ']' && c == '[' || s[i] == ')' && c == '('){
                    popOne(s[i]);
                }

            }
        }
        clear();

    }

    private static void pushOne(char c) {
        chars[++top] = c;
    }
    private static void popOne(char c){
        if(top == -1){
            System.out.println("配对失败");
            return;
        }
        c = chars[top--];
    }
    private static char topOne(){
        return chars[top];
    }

    private static void clear(){
        if(top == -1){
            System.out.println("配对成功");
            return;
        }else{
            System.out.println("配对失败");
            return;
        }
    }
}