专题 查找与排序的Java代码实现（一）

专题 查找与排序的Java代码实现（一）

查找（Searching）

线性查找（linear search）

属于无序查找算法，适合于存储结构为顺序存储或链接存储的线性表。

基本思想：从数据结构线形表的一端开始，顺序扫描，依次将扫描到的结点关键字与给定值k相比较，若相等则表示查找成功；若扫描结束仍没有找到关键字等于k的结点，表示查找失败。

时间复杂度：O(n)

具体代码：

    //-------------------------------------------------------------------------
    //  Searches the specified array of objects using a linear search 线性查找
    //  algorithm. Returns null if the target is not found.
    //-------------------------------------------------------------------------
    public static Comparable linearSearch (Comparable[] data,
                                           Comparable target) {
        Comparable result = null;
        int index = 0;

        while (result == null && index < data.length){
            if (data[index].compareTo(target) == 0)
                result = data[index];
            index++;
        }

        return result;
    }

二分查找（binary search）

属于有序查找算法，元素必须是有序的，如果是无序的则要先进行排序操作。

基本思想：用给定值k先与中间结点的关键字比较，中间结点把线形表分成两个子表，若相等则查找成功；若不相等，再根据k与该中间结点关键字的比较结果确定下一步查找哪个子表，这样递归进行，直到查找到或查找结束发现表中没有这样的结点。

时间复杂度：O(log2n)

具体代码：

    //--------------------------------------------------------------------------
    //  Searches the specified array of objects using a binary search 二分查找
    //  algorithm. Returns null if the target is not found.
    //--------------------------------------------------------------------------
    public static Comparable BinarySearch(Comparable[] data,
                                          Comparable target){
        Comparable result = null;
        int first = 0, last = data.length-1, mid;

        while (result == null && first <= last){
            mid = (first + last) / 2; // determine midpoint
            if (data[mid].compareTo(target)==0)
                result = data[mid];
            else
                if (data[mid].compareTo(target) == 0)
                    result = mid - 1;
                else
                    first = mid + 1;
        }

        return result;
    }

排序（Sorting）

选择排序（selection sort）

基本思想：对一个数列进行排序时，每次从剩余的序列中挑选出最小的记录，放到序列开始位置，以此类推，直到数列的所有数字都已经放到最终位置为止。

时间复杂度：O(n^2)

具体代码：

//-----------------------------------------------------------------
    //  Sorts the specified array of integers using the selection
    //  sort algorithm.
    //-----------------------------------------------------------------
    public static void selectionSort (Comparable[] data) {
        int min;

        for (int index = 0; index < data.length-1; index++) {
            min = index;
            for (int scan = index+1; scan < data.length; scan++)
                if (data[scan].compareTo(data[min]) < 0)
                    min = scan;

            swap (data, min, index);
        }
    }

    //-----------------------------------------------------------------
    //  Swaps two elements in the specified array.
    //-----------------------------------------------------------------
    private static void swap (Comparable[] data, int index1, int index2)
    {
        Comparable temp = data[index1];
        data[index1] = data[index2];
        data[index2] = temp;
    }

插入排序（insertion sort）

基本思想：每次从数列中取一个还没有取出过的数，并按照大小关系插入到已经取出的数中使得已经取出的数仍然有序。

时间复杂度：O(n^2)

具体代码：

//-----------------------------------------------------------------
    //  Sorts the specified array of objects using an insertion
    //  sort algorithm.
    //-----------------------------------------------------------------
    public static void insertionSort (Comparable[] data)
    {
        for (int index = 1; index < data.length; index++)
        {
            Comparable key = data[index];
            int position = index;

            // Shift larger values to the right
            while (position > 0 && data[position-1].compareTo(key) > 0)
            {
                data[position] = data[position-1];
                position--;
            }

            data[position] = key;
        }
    }

冒泡排序（bubble sort）

属于交换排序

基本思想：经过一趟冒泡排序之后，序列中最大的记录到了序列最后，而较小的记录位置均向前移动了

时间复杂度：O(n^2)

具体代码：

 //-----------------------------------------------------------------
    //  Sorts the specified array of objects using a bubble sort
    //  algorithm.
    //-----------------------------------------------------------------
    public static void bubbleSort (Comparable[] data)
    {
        int position, scan;

        for (position = data.length - 1; position >= 0; position--)
        {
            for (scan = 0; scan <= position - 1; scan++)
                if (data[scan].compareTo(data[scan+1]) > 0)
                    swap (data, scan, scan+1);
        }
    }

快速排序（quick sort）

属于交换排序，快速排序是对冒泡排序的一种改进。

基本思想：将待排序序列分成两部分，其中一部分的记录都比另一部分的记录小，随后分别对这两部分再分成两部分，使一部分的记录都小于另一部分，如此反复最终使整个序列最终有序。

时间复杂度：O(n*log2n)

具体代码：

//-----------------------------------------------------------------
    //  Sorts the specified array of objects using the quick sort
    //  algorithm.
    //-----------------------------------------------------------------
    public static void quickSort (Comparable[] data, int min, int max)
    {
        int pivot;

        if (min < max)
        {
            pivot = partition (data, min, max);  // make partitions
            quickSort(data, min, pivot-1);  // sort left partition
            quickSort(data, pivot+1, max);  // sort right partition
        }

    }

    //-----------------------------------------------------------------
    //  Creates the partitions needed for quick sort.
    //-----------------------------------------------------------------
    private static int partition (Comparable[] data, int min, int max)
    {
        // Use first element as the partition value
        Comparable partitionValue = data[min];

        int left = min;
        int right = max;

        while (left < right)
        {
            // Search for an element that is > the partition element
            while (data[left].compareTo(partitionValue) <= 0 && left < right)
                left++;

            // Search for an element that is < the partitionelement
            while (data[right].compareTo(partitionValue) > 0)
                right--;

            if (left < right)
                swap(data, left, right);
        }

        // Move the partition element to its final position
        swap (data, min, right);

        return right;
    }

归并排序（merge sort）

基本思想：重复调用归并算法，首先将单个记录视为一个有序序列，然后不断将相邻的两个有序序列合并得到新的有序序列，如此反复，最后得到一个整体有序的序列

时间复杂度：O(n*log2n)

具体代码：

    //-----------------------------------------------------------------
    //  Sorts the specified array of objects using the merge sort
    //  algorithm.
    //-----------------------------------------------------------------
    public static void mergeSort (Comparable[] data, int min, int max)
    {
        if (min < max)
        {
            int mid = (min + max) / 2;
            mergeSort (data, min, mid);
            mergeSort (data, mid+1, max);
            merge (data, min, mid, max);
        }
    }

    //-----------------------------------------------------------------
    //  Sorts the specified array of objects using the merge sort
    //  algorithm.
    //-----------------------------------------------------------------
    public static void merge (Comparable[] data, int first, int mid,
                              int last)
    {
        Comparable[] temp = new Comparable[data.length];

        int first1 = first, last1 = mid;  // endpoints of first subarray
        int first2 = mid+1, last2 = last;  // endpoints of second subarray
        int index = first1;  // next index open in temp array

        //  Copy smaller item from each subarray into temp until one
        //  of the subarrays is exhausted
        while (first1 <= last1 && first2 <= last2)
        {
            if (data[first1].compareTo(data[first2]) < 0)
            {
                temp[index] = data[first1];
                first1++;
            }
            else
            {
                temp[index] = data[first2];
                first2++;
            }
            index++;
        }

        //  Copy remaining elements from first subarray, if any
        while (first1 <= last1)
        {
            temp[index] = data[first1];
            first1++;
            index++;
        }

        //  Copy remaining elements from second subarray, if any
        while (first2 <= last2)
        {
            temp[index] = data[first2];
            first2++;
            index++;
        }

        //  Copy merged data into original array
        for (index = first; index <= last; index++)
            data[index] = temp[index];
    }