java 常用排序算法

数据结构有必要复习下了


以下是我写的一些算法的实现，请多指教：

import java.util.Arrays;

public class 常用算法实现 {
    /**
     * 数据交换的方法
     * @param v
     * @param i
     * @param j
     */
    public static void swap(int[] v, int i, int j) {
        int temp = v[i];
        v[i] = v[j];
        v[j] = temp;
    }
   
   
    /**
     * 冒泡排序
     *
     * 使用场景：对已经经过初步排序的数据使用比较好
     *
     * 原理：扫描数据交换数据位置 对当前还未排好序的范围内的全部结点， 自上而下对相邻的两个结点依次进行比较和调整，
     * 让键值大的结点往下沉，键值小的结点往上冒。 即，每当两相邻比较后发现它们的排列顺序与排序要求相反时，就将它们互换。
     *
     * 时间复杂度：n的平方 空间复杂度：1
     *
     * 在冒泡排序中的核心部分是 for(i=0;i<n-1;i++) for(j=0;j<n-1-i;j++) if(a[j+1]<a[j])
     * swap(a[j],a[j+1]);
     */
    public static void bubbleUp(int list[]) {
        System.out.println("初始字符串:" + Arrays.toString(list));
        for (int i = 0; i < list.length - 1; i++) {
            boolean flag = false;
            for (int j = 0; j < list.length - i - 1; j++) {
                if (list[j] < list[j + 1]) {
                    swap(list,j,j+1);
                    flag = true;
                }
            }
            if (!flag) {
                break;
            }
            System.out.println("第" + (i + 1) + "次排列:" + Arrays.toString(list));
        }
        System.out.println("最终排列结果:" + Arrays.toString(list));
    }

    /**
     * 选择排序算法
     *
     * 试用场景：数据量比较少的情况下可以使用
     *
     * 原理：这是一个比较简单的算法，他的原理是，首先找到最小的数据 和第一个数据交换，然后再 找到次小的数据和第二个交换，以此类推.直到将数据排列好为止
     *
     * 时间复杂度： 2的n次方
     *
     * 空间复杂度:1
     *
     * @param args
     */
    public static void selectSort(int list[]) {
        System.out.println("初始字符串:" + Arrays.toString(list));
        for (int i = 0; i < list.length - 1; i++) {
            int min = list[i];
            for (int j = i + 1; j < list.length; j++) {
                if (min > list[j]) {
                    min = list[j];
                    swap(list,j,i);

                }
            }
            System.out.println("第" + (i + 1) + "次排列:" + Arrays.toString(list));
        }
        System.out.println("最终排列结果:" + Arrays.toString(list));
    }

    /**
     * 插入排序法 试用场景：数据量比较少的情况下 原理：是一种简单直观的排序算法; 从后到前在已排序数据中找到合适的位置插入进去
     * 初始可认为第一个数据已排序
     *
     * 时间复杂度：n的平方 空间复杂度: n
     *
     * @param args
     */
    public static void insertSort(int list[]) {
        System.out.println("初始字符串:" + Arrays.toString(list));
        // 注意：我们可认为第一个数据已排序，所以i是从1开始的
        for (int i = 1; i < list.length; i++) {
            int temp = list[i];
            int j = i;
            while (j > 0 && list[j] < list[j - 1]) {
                list[j] = list[j - 1];
                j--;
            }
            list[j] = temp;
            System.out.println("第" + i + "次排列:" + Arrays.toString(list));
        }
        System.out.println("最终排列结果:" + Arrays.toString(list));
    }

    /**
     * 快速排序算法
     *
     * 试用场景：数据量比较大的地方,如果有大量重复数据就比较麻烦
     *
     * 原理：首先检查待排序数组，如果<2个 直接推出程序，如果有超过 两个的数据，就选择一个分割点，将数据分成两个部分，小于分割点的分
     * 到一组，大于分割点的放到一组，然后对两组数据进行排序
     *
     * 时间复杂度：快速排序 O(n log n) 空间复杂度：1 splitIndex 划分数据的界限 items 最后字符的位置
     *
     * @param args
     */
    public static void quickSort(int list[], int startIndex, int items) {
        int j, last;
        /* 若数组包含的元素个数少于两个 */
        if (startIndex >= items)
        return;
        swap(list, startIndex, (startIndex + items) / 2); /* 将划分子集的元素移动到V[0] */
        last = startIndex; /* 用last记录中比关键字小间的最右位置 */
        for (j = startIndex + 1; j <= items; j++) /* 划分子集 */
        {
            if (list[j] < list[startIndex]) {
                swap(list, ++last, j);
            }
        }
        quickSort(list, startIndex, items - 1);
        quickSort(list, startIndex + 1, items);
    }

    public static void main(String args[]) {
        int list[] = { 800, 20, 70, 90, 50, 500, 400, 100, 850, 999, 1000, 0,-400 };
         bubbleUp(list);
         selectSort(list);
         insertSort(list);

    }
}