数据结构 第二节 查找与排序算法

 

import java.util.Arrays;

public class SearchAndSort {
    public static void main(String[] args) {
        System.out.println("****** 无序序列查找 ******");
        int[] arr1 = {2,7,49,9,27,12,23,4,45,67};
        System.out.println("arr1原始数组：" + Arrays.toString(arr1));
        System.out.println("目标：23，下标：" + unseqSearch(arr1, 23));

        System.out.println("****** 有序序列查找 ******");
        int[] arr2 = {2,4,7,9,12,23,27,45,67};
        System.out.println("arr2原始数组：" + Arrays.toString(arr2));
        System.out.println("目标：12，下标：" + unseqSearch(arr2, 12));

        System.out.println("****** 二分查找 ******");
        System.out.println("arr2原始数组：" + Arrays.toString(arr2));
        System.out.println("目标：27，下标：" + unseqSearch(arr2, 27));

        System.out.println("****** 插入排序——直接插入排序 ******");
        int[] arr3 = {35,40,5,8,16,90,20,78,5,2};
        System.out.println("arr3原始数组：" + Arrays.toString(arr3));
        insertSort(arr3);
        System.out.println("arr3排序后数组：" + Arrays.toString(arr3));

        System.out.println("****** 插入排序——希尔排序 ******");
        int[] arr4 = {35,40,5,8,16,90,20,78,5,2};
        System.out.println("arr4原始数组：" + Arrays.toString(arr4));
        int[] group = {6,3,1};
        shellSort(arr4, group, 3);
        System.out.println("arr4排序后数组：" + Arrays.toString(arr4));

        System.out.println("****** 选择排序——直接排序 ******");
        int[] arr5 = {35,40,5,8,16,90,20,78,5,2};
        System.out.println("arr5原始数组：" + Arrays.toString(arr5));
        selectSort(arr5);
        System.out.println("arr5排序后数组：" + Arrays.toString(arr5));

        System.out.println("****** 交换排序——冒泡排序 ******");
        int[] arr6 = {35,40,5,8,16,90,20,78,5,2};
        System.out.println("arr6原始数组：" + Arrays.toString(arr6));
        bubbleSort(arr6);
        System.out.println("arr6排序后数组：" + Arrays.toString(arr6));

        System.out.println("****** 交换排序——快速排序 ******");
        int[] arr7 = {35,40,5,8,16,90,20,78,5,2};
        System.out.println("arr7原始数组：" + Arrays.toString(arr7));
        quickSort(arr7);
        System.out.println("arr7排序后数组：" + Arrays.toString(arr7));
    }

    // 无序序列查找
    public static int unseqSearch(int[] arr, int elem){
        int i = 0;
        while(i < arr.length && elem != arr[i]){
            i++;
        }
        return elem == arr[i] ? i : -1;
    }

    // 有序序列查找
    public static int orderSeqSearch(int[] arr, int elem){
        int i = 0;
        while(i < arr.length && elem > arr[i]){
            i++;
        }
        return elem == arr[i] ? i : -1;
    }

    // 二分查找
    public static int binarySearch(int[] arr, int elem){
        int begin = 0;
        int end = arr.length - 1;
        while (begin <= end) {
            int mid = (begin + end)/2;
            if(elem == arr[mid]){
                return mid;
            }else if(elem > arr[mid]){
                begin = mid + 1;
            }else if(elem < arr[mid]){
                end = mid - 1;
            }
        }
        return -1;
    }

    // 直接插入排序
    public static void insertSort(int[] arr){
        int j;
        int temp;
        for (int i = 0; i < arr.length - 1; i++) {
            temp = arr[i + 1];
            j = i;
            while(j > -1 && arr[j] > temp){
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = temp;
        }
    }

    // 希尔排序
    public static void shellSort(int[] arr, int[] group, int loopCount){
        int j;
        int temp;
        int span;
        int n = arr.length;
        for (int m = 0; m < loopCount; m++) {
            span = group[m];
            for (int k = 0; k < span; k++) {
                for (int i = k; i < n - span; i = i + span) {
                    temp = arr[i + span];
                    j = i;
                    while(j > -1 && arr[j] > temp){
                        arr[j + span] = arr[j];
                        j = j - span;
                    }
                    arr[j + span] = temp;
                }
            }
        }
    }

    // 选择排序
    public static void selectSort(int[] arr){
        int j;
        int temp;
        int small;
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            small = i;
            for (j = i + 1; j < n; j++) {
                if(arr[j] < arr[small]){
                    small = j;
                }
            }
            if(small != i){
                temp = arr[small];
                for (j = small; j > i; j--) {
                    arr[j] = arr[j - 1];
                }
                arr[i] = temp;
            }
        }
    }

    // 冒泡排序
    public static void bubbleSort(int[] arr){
        int temp;
        int flag = 1;
        int n = arr.length;
        for (int i = 0; i < n && flag == 1; i++) {
            flag = 0;
            for (int j = 0; j < n - i -1; j++) {
                if(arr[j] > arr[j + 1]){
                    flag = 1;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    // 快速排序
    public static void quickSort(int[] arr){
        int low = 0;
        int high = arr.length -1;
        quickSort(arr, low, high);
    }

    private static void quickSort(int[] arr, int low, int high) {
        int index = partition(arr, low, high);
        if(low < index){
            quickSort(arr, low, index -1);
        }
        if(index < high){
            quickSort(arr, index + 1, high);
        }
    }

    private static int partition(int[] arr, int low, int high) {
        int i = low;
        int j = high;
        int temp = arr[low];
        while(i < j){
            while(i < j && temp <= arr[j]){
                j--;
            }
            if(i < j){
                arr[i] = arr[j];
                i++;
            }
            while(i < j && temp > arr[i]){
                i++;
            }
            if(i < j){
                arr[j] = arr[i];
                j--;
            }
        }
        arr[i] = temp;
        return i;
    }
}