基本排序算法-Java版

冒泡排序

稳定

当前元素和下个元素比较，将较大的元素放在后面

	 // 冒泡排序
     public int[] bubbleSort(int[] nums){
        for (int i = 1; i < nums.length; i++) {
            // 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
            boolean flag = true;

            for (int j = 0; j < nums.length - i; j++) {
                if (nums[j] > nums[j + 1]) {
                    int tmp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = tmp;
                    flag = false;
                }
            }

            if (flag) {
                break;
            }
        }
     }

选择排序

每次从未排序的里面选择最小（大）的，放在已排序队列的未尾

不稳定

	public int[] selectionSort(int[] nums){        
		for (int i = 0; i < nums.length; i++) {
            int temp;
            int min = i;
            for (int j = i+1; j < nums.length; j++) {
                if(nums[j] < nums[min]){
                    min = j;
                }
            }

            temp = nums[min];
            nums[min] = temp;
            nums[i] = temp;
        }
    }

插入排序

类似手上排好序的扑克牌， 进来之后直接插入到适当的位置，按照循序排好

稳定

	 public int[] insertionSort(int[] nums){       
		for (int i = 1; i < nums.length; i++) {
            int value = nums[i];
            for (int j = i-1; j>=0; j--) {
                if(nums[j] < value){
                    break;
                }
                //数据偏移
                nums[j+1] = nums[j];
                nums[j] = value;
            }
        }
     }

并归排序

稳定性

使用分治思想，将序列不断拆分排序，再进行合并排序（合并两个有序数组）。

    public void divideSort(int[] nums, int left, int right){
        if (left >= right)
            return;
        int center = (left+right)/2;
        divideSort(nums,left,center);
        divideSort(nums,center+1,right);
        merge(nums,left,center,right);
    }


	//合作有序数组
    private void merge(int[] nums, int left, int center, int right) {
        
        int r= center+1;
        int p= left,l = left;
        // 临时数组
        int[] tmpArr = new int[nums.length];

        while (l<= center && r <= right) {

            if (nums[l] <= nums[r]) {
                tmpArr[p++] = nums[l++];
            }else {
                tmpArr[p++] = nums[r++];
            }
        }

        while (l<= center){
            tmpArr[p++] = nums[l++];
        }
        while ( r <= right) {
            tmpArr[p++] = nums[r++];
        }

		// 将排好序的数据赋值到nums中
         while (left<=right){
             nums[left] = tmpArr[left];
             left++;
         }

    }

快速排序

不稳定

分治思想， 选取一个基数，小于它的放在左边， 大于它的放在右边，

再将分好的数据按照上面继续分，直达只有一个元素为止，这样，所有的元素都是左边的小，右边的大。

 public void quickSort(int[] nums,int l,int r){

        if(l < r){

            int i=l,j= r;
            int pivot = nums[l];
            // 将小于的基准的放在走边坑位， 大于基准的放在右边坑位
            while (i < j){

                // 从右边找第一个小于pivot的数
                while (i < j && nums[j] >= pivot){
                    j--;
                }
                if(i < j){
                    nums[i++] = nums[j];
                }


                // 从右边找第一个大于等于pivot的数据
                while (i < j && nums[i] < pivot){
                    i++;
                }
                if(i < j){
                    nums[j--] = nums[i];
                }

            }

            nums[i] = pivot;

            // 递归调用
            quickSort(nums, l, i - 1);
            quickSort(nums, i + 1, r);

        }
    }