java排序原理 java排序算法实现

目录

直接插入排序

希尔排序

选择排序

选择排序优化：

冒泡排序

堆排序

快速排序

Hoare法拆分

挖空法拆分 

前后指针法拆分

快速排序的优化：

非递归的快速排序

归并排序

递归方法

非递归方法

计数排序

---

交换函数

public static void swap(int[] array, int index1, int index2){
        int tmp = array[index1];
        array[index1] = array[index2];
        array[index2] = tmp;
    }

直接插入排序

时间复杂度：O(n^2) ,空间复杂度O(1),稳定

//直接插入排序 升序
    public void insertSort(int[] array){
        for(int i = 1; i < array.length ; i++){
            int tmp = array[i];
            int j = i-1;
            for(; j >= 0; j--){
                if(array[j] > tmp){
                    array[j+1] = array[j];  //将大于tmp的数后移
                }else{
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }

希尔排序

缩小增量算法

时间复杂度：O(N^1.5) ,空间复杂度O(1),不稳定

//希尔排序
    public void shellSort(int[] array){
        int gap = array.length;

        while(gap >= 1){
            for(int i = gap; i < array.length ; i++){
                int tmp = array[i];
                int j = i-gap;

                while(j >= 0){
                    if(array[j] > tmp){
                        array[j+gap] = array[j];
                    }else{
                        break;
                    }
                    j -= gap;
                }
                array[j+gap] = tmp;
            }
            gap /= 2;
        }
    }

选择排序

时间复杂度：O(N^2) ,空间复杂度O(1),不稳定

//直接选择排序
    public void selectSort(int[] array){
        for(int i = 0; i < array.length ; i++){
            int index = i;
            for(int j = i+1 ; j < array.length; j++){
                //寻找最小值
                if(array[j] < array[index]){
                    index = j;
                }
            }
            if(array[i] != array[index]){
                swap(array,i,index);
            }
        }
    }

选择排序优化：

在遍历的时候，同时找到最小值和最大值，减少遍历次数

//直接选择排序优化
    public void selectSort2(int[] array){
        int left = 0;
        int right = array.length-1;
        while(left < right){
            int minIndex = left;
            int maxIndex = right;
            for(int j = left+1; j < right ; j++){
                if(array[j] < array[minIndex]){
                    minIndex = j;
                }
                if(array[j] > array[maxIndex]){
                    maxIndex = j;
                }
            }
            if(array[left] != array[minIndex]){
                swap(array,minIndex,left);
            }
            if(array[right] != array[maxIndex]){
                swap(array,maxIndex,right);
            }
            left++;
            right--;
        }
    }

冒泡排序

时间复杂度：O(N^2) ,空间复杂度O(1),稳定

//冒泡排序
    public void bubbleSort(int[] array){
        for(int i = 0 ; i < array.length ; i++){
            boolean flag = true;
            for(int j = 0;j < array.length-i-1 ; j++){
                if(array[j] > array[j+1]){
                    swap(array,j,j+1);
                    flag = false;
                }
            }
            //flag为true则说明已经有序
            if(flag){
                break;
            }
        }
    }

堆排序

时间复杂度：O(N*logN) ,空间复杂度O(1),不稳定

/**
     * 堆排序
     * 创建大根堆，然后将堆顶元素往后放
     */
    public void heapSort(int[] array){
        createBigHeap(array);
        int last = array.length-1;

        while(last >= 0){
            swap(array,last,0);
            shiftDown(array,0,last);
            last--;
        }

    }

    //创建大根堆
    public void createBigHeap(int[] array){
        for(int parent = (array.length-1-1)/2; parent >= 0; parent--){
            shiftDown(array,parent,array.length);
        }
    }

    //向下调整
    public void shiftDown(int[] array,int root,int end){
        int child = root*2 + 1;

        while(child < end){
            if(child+1 < end && array[child+1] > array[child]){
                child++;
            }
            if(array[child] > array[root]){
                swap(array,child,root);

            }else{
                break;
            }
            root = child;
            child = root*2 + 1;
        }
    }

快速排序

时间复杂度：O(N*logN) ,空间复杂度O(log(N))~O(N),不稳定

递归：

public void quickSort(int[] array,int left,int right){
        if(left < right){
            int pivot = partitionPointer2(array,left,right);

            quickSort(array,left,pivot-1);        //递归左边部分
            quickSort(array,pivot+1,right); //递归右边部分
        }
    }

pivot为基准值下标，partition为拆分方法

Hoare法拆分

//Hoare法拆分
    public static int partitionHoare(int[] array,int start,int end){
        int i = start; //记录起始下标
        int key = array[start];
        while(start < end){
            while(start < end && array[end] >= key){
                end--;
            }
            while(start < end && array[start] <= key){
                start++;
            }
            //交换start和end下标的值
            swap(array,start,end);
        }
        //交换start下标和起始下标的值
        swap(array,i,start);

        return start; //返回start下标
    }

挖空法拆分 

//挖空法拆分
    public static int partitionHole(int[] array, int left, int right){
        int key = array[left];
        int i = left;
        int j = right;
        while(i < j){
            while(i < j && array[j] >= key){
                j--;
            }
            array[i] = array[j];   //将小于基准key的值放入左下标i的位置中
            while(i < j && array[i] <= key){
                i++;
            }
            array[j] = array[i];   //将大于基准key的值放入左下标j的位置中
        }
        array[i] = key;
        return i;
    }

前后指针法拆分

//前后指针法
    public static int partitionPointer(int[] array,int left,int right){
        int i = left;
        int j = left+1;
        while(j <= right){
            //array[left]为基准值
            if(array[j] < array[left] && array[++i] != array[left]){
                swap(array,i,j);
            }
            j++;
        }
        swap(array,left,i);
        return i;
    }

    //前后指针法2
    public static int partitionPointer2(int[] array, int left,int right){
        int d = left+1;
        int pivot = array[left];
        for(int i = left+1; i <= right ; i++){
            if(array[i] < pivot){
                swap(array,d,i);
                d++;
            }
        }
        swap(array,d-1,left);
        return d-1;
    }

快速排序的优化：

在对有序数组排序时，递归的快排可能会导致栈溢出

优化点：1、在区间较小时，使用直接插入排序 2、对基准值的选取采用三数取中法，避免递归时深度过高

//三数取中
    public static int midIndex(int[] array, int left ,int right){
        int mid = (left + right)/2;
        if(array[left] < array[right]){
            if(array[left] > array[mid]){
                return left;
            }else if(array[right] > array[mid]){
                return mid;
            }else{
                return right;
            }
        }else{
            if(array[right] > array[mid]){
                return right;
            }else if(array[mid] < array[left]){
                return mid;
            }else{
                return left;
            }
        }
    }

    //快排优化  解决有序时递归深度过深的问题
    public void quicker(int[] array,int left,int right){
        if(right > left){
            //小区间用直接插入排序
            if(right - left <= 6){
                insertSort(array);
                return;
            }
            int midIndex = midIndex(array,left,right);
            swap(array,midIndex,left);   //交换值

            int pivot = partitionHole(array,left,right);

            quicker(array,left,pivot-1);
            quicker(array,pivot,right);
        }
    }

非递归的快速排序

//非递归快排
    public void quickSortNotR(int[] array){
        Stack<Integer> stack = new Stack<>();
        int left = 0;
        int right = array.length-1;

        int index = midIndex(array,left,right);
        swap(array,left,index);

        int pivot = partitionHole(array,left,right); //基准值下标

        if(pivot > left+1){
            //左树left和right入栈
            stack.push(left);
            stack.push(pivot - 1);
        }
        if(pivot < right-1){
            //右树left和right入栈
            stack.push(pivot+1);
            stack.push(right);
        }

        while(!stack.empty()){
            right = stack.pop();
            left = stack.pop();
            index = midIndex(array,left,right);

            swap(array,left,index);

            pivot = partitionHole(array,left,right);

            //有左树，则继续入栈
            if(pivot > left+1){
                stack.push(left);
                stack.push(pivot-1);
            }
            //有右树，继续入栈
            if(pivot < right-1){
                stack.push(pivot +1);
                stack.push(right);
            }
        }
    }

归并排序

时间复杂度：O(N*log(N)) ,空间复杂度O(N),稳定

递归方法

//归并排序 （递归）
    public void mergeSort(int[] array, int left, int right){
        if(left < right){
            int mid = (left+right)/2;
             mergeSort(array,left,mid);             //分解左边
             mergeSort(array,mid+1,right);      //分解右边
             merge(array,left,mid,right);        //合并数组
        }
    }

    //合并两个小数组
    public void merge(int[] array,int left,int mid,int right){
        int[] tmpArray = new int[right-left+1];   //创建数组

        int p1 = left;   //第一个数组的指针
        int p2 = mid+1;  //第二个数组的指针
        int p = 0;       //大数组的指针

        while(p1 <= mid && p2 <= right){
            if(array[p1] <= array[p2]){
                tmpArray[p++] = array[p1++];
            }else{
                tmpArray[p++] = array[p2++];
            }
        }

        while(p1 <= mid){
            tmpArray[p++] = array[p1++];
        }
        while(p2 <= right){
            tmpArray[p++] = array[p2++];
        }

        //把归并好的数组拷贝回原数组
        for(int i = 0; i < p; i++){
            array[left+i] = tmpArray[i];
        }
    }

非递归方法

//归并排序 （非递归）
    public void mergeSortNoneR(int[] array){
        int gap = 1;

        while(gap < array.length){
            //for循环归并小数组
            for(int i = 0; i < array.length; i += gap*2){
                int start1 = i;
                int end1 = start1 + gap -1;
                if(end1 >= array.length){
                    end1 = array.length-1;
                }
                int start2 = end1+1;
                if(start2 >= array.length){
                    start2 = array.length-1;
                }
                int end2 = start2+gap-1;
                if(end2 >= array.length){
                    end2 = array.length-1;
                }
                //归并小区间
                merge(array,start1,end1,end2);
            }
            gap *= 2;
        }

    }

计数排序

//计数排序
    public void countSort(int[] array){
        int max = array[0];
        int min = array[0];
        //找到最大最小值
        for(int i = 1; i < array.length; i++){
            if(array[i] <= min){
                min = array[i];
            }
            if(array[i] >= max){
                max = array[i];
            }
        }

        int[] tmpArray = new int[max-min+1];   //创建计数数组

        for(int i = 0; i < array.length ; i++){
            //计数
            tmpArray[array[i]-min]++;
        }

        int count = 0;    //原数组下标
        int countTmp = 0; //计数数组下标

        while(count != array.length){
            while(tmpArray[countTmp] == 0){
                countTmp++;
            }
            array[count] = min + countTmp++;
            count++;
        }
    }