《趣学算法》第三章 分治法代码实现（Java）

3.2 二分搜索技术

import java.util.Scanner;
import java.util.Arrays;

/*二分搜索技术*/
public class Test3_2 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入数列中的元素个数n为：(输入-1程序结束)");
        int n=scanner.nextInt();
        while(n!=-1) {
            int[] s=new int[n];
            System.out.println("请依次输入数列中的元素：");
            for(int i=0;i<n;i++)
                s[i]=scanner.nextInt();
            Arrays.sort(s);                                  //对数组排序，二分查找要求数列必须有序                            
            System.out.println("排序后的数组为：");
            for(int i=0;i<n;i++)
                System.out.print(s[i]+" ");
            System.out.println();
            System.out.println("请输入要查找的元素：");
            int x=scanner.nextInt();
            int ans=binarySearch(s,x);                     //在数组s中查找元素x
            if(ans==-1)
                System.out.println("改数列中没有要查找的元素");
            else
                System.out.println("要查找的元素在第"+(ans+1)+"位");

            System.out.println("请输入数列中的元素个数n为：(输入-1程序结束)");
            n=scanner.nextInt();
        }
    }

    /*二分查找*/
    public static int binarySearch(int[] s,int x) {
        int low=0;                                         //low指向数组第一个元素
        int high=s.length-1;                               //high指向数组最后一个元素
        while(low<=high) {                                 //主要low<=high就进入循环
            int middle=(low+high)/2;                       //middle为查找范围的中间值
            if(x==s[middle])                               //x等于查找范围的中间值，算法结束
                return middle;
            else if(x<s[middle])                           //x小于查找范围的中间元素，则从前半部分查找
                high=middle-1;                             //重新设置high
            else                                           //x大于查找范围的中间元素，则从后半部分查找
                low=middle+1;
        }
        return -1;
    }
}

程序运行结果如下：

3.3合并排序

import java.util.Scanner;

public class Test3_3 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入数列中的元素个数n为：");
        int n=scanner.nextInt();
        System.out.println("请依次输入数列中的元素：");
        int[] A=new int[n];
        for(int i=0;i<n;i++)
            A[i]=scanner.nextInt();
        mergeSort(A,0,n-1);

        System.out.println("合并排序的结果：");
        for(int i=0;i<n;i++)
            System.out.print(A[i]+" ");
    }

    /*递归的合并排序算法*/
    public static void mergeSort(int[] A,int low,int high) {
        if(low<high) {
            int mid=(low+high)/2;
            mergeSort(A,low,mid);                             //对A[low...mid]中的元素合并排序
            mergeSort(A,mid+1,high);                          //对A[mid+1...high]中的元素合并排序
            merge(A,low,mid,high);                            //合并操作
        }
    }

    public static void merge(int[] A,int low,int mid,int high) {
        int[] B=new int[A.length];                            //辅助数组
        int i=low,j=mid+1;                                    //i,j分别指向两个待合并子序列中当前待比较的元素
        int k=0;                                              //k指向辅助数组待放置元素的位置
        while(i<=mid&&j<=high) {
            if(A[i]<=A[j])                                    //按从小到大顺序放入B数组中
                B[k++]=A[i++];
            else
                B[k++]=A[j++];
        }

        while(i<=mid)
            B[k++]=A[i++];                                    //对子序列A[low...mid]剩余的元素进行处理
        while(j<=high)
            B[k++]=A[j++];                                    //对子序列A[mid+1...high]剩余的元素进行处理

        for(i=low,k=0;i<=high;i++)
            A[i]=B[k++];                                        //将合并后的序列存放回原数组
    }
}

程序运行结果如下：

3.4快速排序

import java.util.Scanner;

public class Test3_4 {

    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请先输入要排序的数据的个数：");
        int N=scanner.nextInt();
        System.out.println("请输入要排序的数字：");
        int[] R=new int[N];
        for(int i=0;i<N;i++)
            R[i]=scanner.nextInt();

        quickSort(R,0,N-1);                                //调用快速排序算法
        System.out.println("排序后的序列为：");
        for(int i=0;i<N;i++)
            System.out.print(R[i]+" ");
    }

    /*快速排序递归算法*/
    public static void quickSort(int[] R,int low,int high) {
        int mid;
        if(low<high) {
            mid=partition(R,low,high);                     //对原序列进行分解，找到基准位置
            quickSort(R,low,mid-1);                        //左区间递归快速排序
            quickSort(R,mid+1,high);                       //右区间递归快速排序
        }
    }

    /*划分函数，找到基准元素的位置*/
    public static int partition(int[] R,int low,int high) {
        int i=low,j=high;
        int pivot=R[low];                                  //取第一个元素做基准
        while(i<j) {
            while(i<j&&R[j]>pivot)                         //从右向左扫描，若R[j]大于基准则继续向左走
                j--;
            if(i<j) {                                      //while循环跳出说明找到一个小于基准的元素
                int temp=R[i];                             //交换元素位置
                R[i]=R[j];
                R[j]=temp;
                i++;
            }
            while(i<j&&R[i]<pivot)                         //从左向右扫描，若R[i]小于基准则继续向右走
                i++;
            if(i<j) {                                      //while跳出循环说明找到一个大于基准的元素
                int temp=R[i];                             //交换位置
                R[i]=R[j];
                R[j]=temp;
                j--;
            }
        }
        return i;
    }
}

程序运行结果如下：