经典排序与查找算法详解-优快云博客

Java学习（四）算法

算法

版权声明：本文为优快云博主「jackesy」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/jackesy/article/details/80135033

算法

经典排序算法

在这里插入图片描述

插入排序

将右侧无序数据取出，与左侧有序数据最后一个数据比较，小于则交换位置。

    public static void insertSort(int[] array) {
        for (int i = 1; i < array.length; i++) {
            int num = array[i];
            int j = i - 1;
            for (; j >= 0 && array[j] >= num; j--) {
                array[j + 1] = array[j];
            }
            array[j + 1] = num;
        }
        System.out.println(Arrays.toString(array) + " insertSort");
    }

希尔排序

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率
但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位

    public static void test(int[] array) {
        int x, y;
        int gap = 1;
        int len = array.length;
        while (gap < len / 3) {
            gap = gap * 3 + 1;
        }
        for (; gap > 0; gap /= 3) {
            for (x = gap; x < len; x++) {
                int temp = array[x];
                for (y = x - gap;y >= 0 && array[y] > temp; y = y - gap) {
                    array[y + gap] = array[y];
                }
                array[y + gap] = temp;
            }
        }
        System.out.println(Arrays.toString(array) + " shellSort");
    }

选择排序

是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

public static void selectSort(int[] array) {
    int position = 0;
    for (int i = 0; i < array.length; i++) {
        int j = i + 1;
        position = i;
        int temp = array[i];
        for (; j < array.length; j++) {
            if (array[j] < temp) {
                temp = array[j];
                position = j;
            }
        }
        array[position] = array[i];
        array[i] = temp;
    }
    System.out.println(Arrays.toString(array) + " selectSort");
}

堆排序

是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子节点的键值或索引总是小于（或者大于）它的父节点。

    public static void main(String[] args) {
        test(TEXT);
    }

    public static void test(int[] array) {
        int len = array.length;
        int begin = len / 2 - 1;
        System.out.println("index " + begin + " len " + len);
        for (int i = begin; i >= 0; i--) {
            testMaxHeap(i, len - 1, array);
        }

        System.out.println(Arrays.toString(array) + " heapSort");

        for (int i = len; i > 0; i--) {
            swap(0, i - 1, array);
            testMaxHeap(0, i - 2, array);
        }
        System.out.println(Arrays.toString(array) + " heapSort");
    }

    public static void testMaxHeap(int index, int len, int[] arr) {
        int li = index * 2 + 1;
        int ri = index * 2 + 2;
        System.out.println("index " + index + " l " + li + " r " + ri);
        int temp = arr[index];
        int max = li;
        if (li > len) {
            return;
        }
        if (ri <= len && arr[ri] > arr[li]) {
            max = ri;
        }
        if (arr[max] > temp) {
            swap(max, index, arr);
            testMaxHeap(max, len, arr);
        }
    }

冒泡排序

是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

public static void bubbleSort(int[] array) {
    int temp = 0;
    for (int i = 0; i < array.length - 1; i++) {
        for (int j = 0; j < array.length - 1 - i; j++) {
            if (array[j] > array[j + 1]) {
                temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
    System.out.println(Arrays.toString(array) + " bubbleSort");
}

快速排序

又称划分交换排序，简称快排，一种排序算法。

public static void quickSort(int[] array) {
    _quickSort(array, 0, array.length - 1);
    System.out.println(Arrays.toString(array) + " quickSort");
}
 
 
private static int getMiddle(int[] list, int low, int high) {
    int tmp = list[low];    //数组的第一个作为中轴
    while (low < high) {
        while (low < high && list[high] >= tmp) {
            high--;
        }
 
 
        list[low] = list[high];   //比中轴小的记录移到低端
        while (low < high && list[low] <= tmp) {
            low++;
        }
 
 
        list[high] = list[low];   //比中轴大的记录移到高端
    }
    list[low] = tmp;              //中轴记录到尾
    return low;                  //返回中轴的位置
}
 
 
private static void _quickSort(int[] list, int low, int high) {
    if (low < high) {
        int middle = getMiddle(list, low, high);  //将list数组进行一分为二
        _quickSort(list, low, middle - 1);      //对低字表进行递归排序
        _quickSort(list, middle + 1, high);      //对高字表进行递归排序
    }
}

归并排序

是创建在归并操作上的一种有效的排序算法，效率为{O(n\log n)。1945年由约翰·冯·诺伊曼首次提出。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行。

public static void mergingSort(int[] array) {
    sort(array, 0, array.length - 1);
    System.out.println(Arrays.toString(array) + " mergingSort");
}
 
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[] tmpArr = new int[data.length];
    int mid = center + 1;
    //third记录中间数组的索引
    int third = left;
    int tmp = left;
    while (left <= center && mid <= right) {
        //从两个数组中取出最小的放入中间数组
        if (data[left] <= data[mid]) {
            tmpArr[third++] = data[left++];
        } else {
            tmpArr[third++] = data[mid++];
        }
    }
 
    //剩余部分依次放入中间数组
    while (mid <= right) {
        tmpArr[third++] = data[mid++];
    }
 
    while (left <= center) {
        tmpArr[third++] = data[left++];
    }
 
    //将中间数组中的内容复制回原数组
    while (tmp <= right) {
        data[tmp] = tmpArr[tmp++];
    }
}

经典查找算法

线性查找

在待查数据中进行顺序性轮询查找，当存在待查的数据时返回当前数据索引位置，如果不存在则返回不存在表示-1，技巧为了增加效率减少主要代码的操作，可以设置一个监视哨在数组的最后一位，这样就可以有效的防止数据越界的比较了只需要比较当前数据是否是所需要的数据就OK了。O(N)

二分查找

    public static int halfSort(int[] data, int key) {
        int left = 0;//左标记
        int right = data.length - 1;//右标记
        int result = -1;
        while (left <= right) { //进行中间判断
            int half = (left + right) / 2;
            if (data[half] == key) {
                result = half;
                break;
            } else if (data[half] < key) {
                left = half;
            } else {
                right = half;
            }
        }
        return result;
    }

    public static void main(String[] args) {
        int[] number = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int key = 6;
        int result = halfSort(number, key);
        if (result == -1) {
            System.out.println("当前数据不存在");
        } else {
            System.out.println(result);
        }
    }