手写排序算法

(1)冒泡排序

//冒泡排序，每一次总是把最大的数防置到最后
public static int[] bubbleSort(int[] numbers) {
        int size = numbers.length;
        for(int i=0;i

(2)选择排序

    //选择排序：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
    public static  int[] selectSort(int[] numbers) {
        int size= numbers.length;
        for(int i=0;ii;j--) {
                //从一趟中找到最大/最小的那个
                if(numbers[j]

(3)插入排序

    //插入排序：每次都与左边的值比较，若小于/大于就像左边移动
    public static int[] insertSort(int[] numbers) {
        int size= numbers.length,temp,j;
        for(int i=1;i 0 && temp < numbers[j - 1]; j--) {
                numbers[j] = numbers[j - 1];   
             }  
                //移动后面把自己放进去
                numbers[j] = temp;  
        }
        return numbers;
    }

(4)快速排序

public static void main(String[] args) {
        int[] arr = {6,1,2,4,3,4,5,3,5,7,9,11,12,10,25};
        QuickSort(arr,arr.length,0,arr.length-1);
        for(int i :arr) System.out.print(i+",");
    }
    static void QuickSort(int[] data,int length,int start,int end){
        if(start==end) return;
        int index=quickSort(data,length,start,end);
        if(index>start){
            QuickSort(data,length,start,index-1);
        }
        if(indexstart) {
//          QuickSort(data,length,start,index-1);
//      }else if(index

(5)堆排序

private int[] buildMaxHeap(int[] array) {
        //从根节点的最后一个叶子结点的父节点开始，之后依次向上的完善
        for(int i=(array.length-2)/2;i>=0;i--) {
            adjustDownToUp(array,i,array.length);
        }
        return array;
    }

    private static void adjustDownToUp(int[] array, int k, int length) {
        int temp =array[k];
        //初始点为k的左孩子，之后继续以向下的左孩子对下面进行树排序
        for (int i = 2*k+1; i array[i]) { //根节点大于左右子节点，则直接的break掉
                break;
            }else {   
                //替换点根节点，然后向下移动构建
                array[k]=array[i];
                k=i;
            }
        }
        array[k]=temp;
    }
    
    //对堆进行逆排序
    public int[] heapSort(int[] array) {
        //先创建堆
        array = buildMaxHeap(array);
        for (int i =array.length-1;i>1;i--) {
            //用堆的最小一个节点与堆的最大节点进行交换
            int temp = array[0];
            array[0] = array[i];
             array[i] = temp;
             //重新的调整堆
             adjustDownToUp(array,0,i);
        }
        
        return array;
    }
    
    //删除堆顶元素的操作
    public int[] deleteMax(int[] array) {
        //将堆的最后一个元素与堆顶元素交换，堆底元素值设为0
        array[0] = array[array.length-1];
        array[array.length-1]=0;
        //对此时的根节点进行向下调整
        adjustDownToUp(array,0,array.length);
        return array;
    }
    //插入操作:向大根堆array中插入数据data
    public int[] insertData(int[] array,int data) {
        array[array.length-1]=data;//将新节点放在堆的末端
        int k =array.length-1;//需要调整的节点
        int parent = (k-1)/2; //双亲节点
        while (parent>0&& data>array[parent]) {
            array[k] =array[parent];//双亲节点下调
            k=parent;
            if(parent!=0) {
                parent=(parent-1)/2;
            }else {
                break;
            }
        }
        array[k]=data;//将插入的结点放到正确的位置
        return array;
    }
    public void toString(int[] arrays){
        for (int i : arrays) {
            System.out.print(i+" ");
        }
    }
    public static void main(String[] args) {
        HeapSort hs = new HeapSort();
        int[] array={87,45,78,32,17,65,53,9,122};
        System.out.println("构建最大堆");
        hs.toString(hs.buildMaxHeap(array));
        System.out.println("\n"+"堆排序");
        hs.toString(hs.heapSort(array));
        System.out.println("\n"+"删除栈顶元素：");
        hs.toString(hs.deleteMax(array));
        System.out.println("\n"+"插入元素63：");
        hs.toString(hs.insertData(array, 63));
        System.out.println("\n"+"大根堆排序：");
        hs.toString(hs.heapSort(array));
    }

(6)不重复数组找第K大

public static void main(String[] args) {
        int[] arr = {1,2,4,5,6,7,9};
        
        int Arr = findKthLargestofArr(arr,3);
        int Heap = findKthLargestofHeap(arr,3);
        System.out.println(Arr+" "+Heap);
    }
    public static int findKthLargestofArr(int[] nums, int k) {
        Arrays.sort(nums);
        return nums[nums.length - k];
    }
    
     public static int findKthLargestofHeap(int[] nums, int k) {
        PriorityQueue q = new PriorityQueue(k);
        for (int i : nums) {
            q.offer(i);

            if (q.size() > k) {
                q.poll();
            }
        }
        return q.peek();
    }