数据结构与算法【冒泡排序 快速排序 】

冒泡排序：

第一轮比较之后的结果：

如此循环开始第二轮比较

最后结果：

看这幅图片冒泡排序的核心思想是将相邻元素进行比较，想排成升序就把小的元素向前放置，排成降序就将大的元素向前放置。那既然提到排序我们这里用到for循环遍历数组，在利用第二层for循环把轮数进行把控。那我们这里应该想到一种情况就是如果这个数组他本身就是有序的那我再用算法对他进行排序那岂不是很浪费资源。这里定义一个标志性的flag将他置为假，如果经过了一轮比较他还是假那就证明这个数组本身就是有序的状态，到这里就可以退出循环，不再进行比较了，与此同时我们只通过了一轮就验证出他是有序的，就节省了许多不必要的空间浪费。

public static void main(String[] args) {
        int[] arr = {6, 5, 4, 3, 2, 1};
        int[] result = sort(arr);
        System.out.println(Arrays.toString(result));
    }


    public static int[] sort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            boolean flag = true;
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    flag = false;
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            if (flag) {
                break;
            }
        }
        return arr;
    }

快速排序：

快速排序的核心思想是找到数组的中间元素，以他作为基准。然后定义两个指针分别从数组的左边和右边对数组进行遍历。也就是排序后的元素在基准数字左边的全部小于他，在基准数字右边的全部大于他，既然知道了这个目的，那指针在进行遍历的时候，左指针向右走，右指针向左走，直到遇到左指针指向的元素大于基准元素，右指针指向的元素小于基准元素，这个时候进行交换。

图片讲解：

第一次交换

//快速排序
    public static void main(String[] args) {

        int[] arr = new int[]{5, 6, 4, 3, 1, 2};
        Sort(arr, 0, 5);
        System.out.println(Arrays.toString(arr));

    }


    public static void Sort(int[] arr, int startIndex, int endIndex) {
        if (startIndex >= endIndex) {
            return;
        }
        int pIndex = partition(arr, startIndex, endIndex);

        Sort(arr, startIndex, pIndex - 1);
        Sort(arr, pIndex + 1, endIndex);
    }


    public static int partition(int[] arr, int startIndex, int endIndex) {


        int p = arr[startIndex];
        int left = startIndex;
        int right = endIndex;

        while (left != right) {

            //寻找右侧元素
            while ((left < right) && (arr[right] > p)) {
                right--;
            }

            //寻找左侧元素
            while ((left < right) && (arr[left] <= p)) {
                left++;
            }

            if (left < right) {
                int temp = arr[left];
                arr[left] = arr[right];
                arr[right] = temp;
            }

        }

        arr[startIndex] = arr[left];
        arr[left] = p;

        return p;
    }

插入排序：

插入排序的核心思想是将无序数组插入到有序数组里面。然后依次进行排序，详细见图。

第一层循环先遍历无序数组，将元素进行放入，利用第二层循环遍历插入后的数组，如果有前一个小于后一个就进行交换。直到排序结束。

public static void main(String[] args) {

        int[] arr = {5, 6, 4, 3, 2, 1};


        int temp = 0;
        for (int i = 1; i < arr.length; i++) {
            for (int j = i; j >= 1; j--) {
                if (arr[j] < arr[j - 1]) {
                    temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                } else {
                    break;
                }
            }
        }

        System.out.println(Arrays.toString(arr));

    }