哔哩哔哩左程云算法与数据结构笔记P3

一、堆结构：（堆是完全二叉树）

       · i位置（在size内）的：左孩子：2*i+1

                                             右孩子：2*i+2

                                             父：       (i-1)/2      (向下取整)

大根堆：

heapInsert：（）

public static void heapInsert(int[] arr, int index)
    {
        while(arr[index] > arr[(index - 1)/ 2])
        {
            swap(arr, index, (index - 1)/2);
            index = (index - 1) /2;
        }
    }

 heapify：（最大/大根堆的下沉）()

public static void heapify(int[] arr, int index, int heapsize)
{
    int left = index * 2 + 1;
    while(left < heapsize) {
        int largest = left + 1 < heapsize && arr[left + 1] > arr[left] ? left + 1 : left;
        largest = arr[largest] > arr[index] ? largest : index;
        if (largest == index)
        {
            break;
        }
        swap(arr, index, largest);
        index = largest;
        left = index * 2 + 1;
    }
}

问：若用户修改heapsize内的任意一个数为“?”，要求重新实现大根堆。

        当?变大时，用heapinsert；当?变小时，用heapify。

二、堆排序（heapsort）

得到一个数组后，把它变为大根堆（做heapinsert

），再取最大的数（即最高节点）和数组最后一个数做swap，并且heapsize--，做heapify，一直重复上述步骤，就实现了堆排序。

public static void heapsort(int[] arr)//时间复杂度为o(nlogn)   空间复杂度o(1)
{
    if(arr == null || arr.length < 2)
    {
        return;
    }
    for(int i = 0;i < arr.length;i++)
    {
        heapinsert(arr,i);
    }
    int heapsize = arr.length;
    swap(arr, 0, --heapsize);
    while(heapsize > 0)
    {
        heapify(arr, 0, heapsize);
        swap(arr, 0, --heapsize);
    }
}

对于把数组变成大根堆形式的代码，当一次性把所有数都给出来时，做如下简化，可以把时间复杂度稍微变快一点点。

for(int i = arr.length - 1;i >= 0;i--)
{
    heapify(arr, i, arr.length);
}

 总代码如下：

public class javatest {
    public static void main(String[] args) {
        int[] heap = {8,5,4,1,2,3,7,6,9};
        heapsort(heap);
        for(int i = 0; i < heap.length; i++)
        {
            System.out.print(heap[i] + " ");
        }
    }
    public static void heapsort(int[] arr)//时间复杂度为o(nlogn)   空间复杂度o(1)
    {
        if(arr == null || arr.length < 2)
        {
            return;
        }
        for(int i = 0;i < arr.length;i++)
        {
            heapinsert(arr,i);
        }
        int heapsize = arr.length;
        swap(arr, 0, --heapsize);
        while(heapsize > 0)
        {
            heapify(arr, 0, heapsize);
            swap(arr, 0, --heapsize);
        }
    }
    public static void heapinsert(int[] arr, int index)
    {
        while(arr[index] > arr[(index - 1)/ 2])
        {
            swap(arr, index, (index - 1)/2);
            index = (index - 1) /2;
        }
    }
    public static void swap(int[] arr, int i, int j)
    {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    public static void heapify(int[] arr, int index, int heapsize)
    {
        int left = index * 2 + 1;
        while(left < heapsize) {
            int largest = left + 1 < heapsize && arr[left + 1] > arr[left] ? left + 1 : left;
            largest = arr[largest] > arr[index] ? largest : index;
            if (largest == index)
            {
                break;
            }
            swap(arr, index, largest);
            index = largest;
            left = index * 2 + 1;
        }
    }
}

 用到了优先队列，底层还是堆，默认是最小堆

public static void sortedArrayDistanceLessK(int[] arr,int k)
{
    PriorityQueue<Integer> heap = new PriorityQueue<>();
    int index = 0;
    for(;index <= Math.min(arr.length, k);index++)
    {
        heap.add(arr[index]);
    }
    int i = 0;
    for(;index < arr.length;i++, index++)
    {
        heap.add(arr[index]);
        arr[i] = heap.poll();
    }
    while(!heap.isEmpty())
    {
        arr[i++] = heap.poll();
    }
}

三、比较器 

所谓“潜台词”：返回负数：第一个参数在前面

                        返回正数：第二个参数在前面

                        返回零：谁在前面无所谓

以视频中的学生为例

public static class Student
    {
        public String name;
        public int id;
        public int age;
        public Student(String name, int id, int age)
        {
            this.name = name;
            this.id = id;
            this.age = age;
        }
    }
    public static class IdAscentingComparator implements Comparator<Student> {
        public int compare(Student o1, Student o2) {
            return o1.age - o2.age;//升序排序  若要实现降序，只需交换o1 o2的顺序
        }
    }

Arrays.sort(students, new IdAscentingComparator() {});
//调用时用此格式

更复杂时：先按年龄排序，再按id排序

public static class AgeAscentingComparator implements Comparator<Student> {
    public int compare(Student o1, Student o2) {
        if(o1.age != o2.age)
        {
            return o1.age - o2.age;
        }
        return o1.id - o2.id;//比较器的好处是可应对复杂情况
    }
}

四、桶排序 

计数排序排序是不基于比较的排序，需要根据数据状况来定制，面很窄，数据量大的时候不适用。

桶排序（radixSort）：

条件：需要数据有进制

下面是完整代码：使用时调用radixSort即可

public static int maxbits(int[] arr)
    {
        int max = Integer.MIN_VALUE;
        for(int i = 0;i < arr.length;i++)
        {
            max = Math.max(max, arr[i]);
        }
        int res = 0;
        while(max > 0)
        {
            res++;
            max /= 10;
        }
        return res;
    }
    public static void radixSort(int[] arr, int L, int R, int digit)
    {
        final int radix = 10;
        int i = 0, j = 0;
        int[] bucket = new int [R - L + 1];
        for(int d = 1;d <= digit;d++)
        {
            int[] count = new int [R - L + 1];
            for(i = L;i <= R;i++)
            {
                j = getDigit(arr[i], d);
                count[j]++;
            }
            for(i = 1;i < radix;i++)
            {
                count[i] = count[i] + count[i - 1];
            }
            for(i = R;i >= L;i--)
            {
                j = getDigit(arr[i], d);
                bucket[count[j] - 1] = arr[i];
                count[j]--;
            }
            for(i = L, j = 0;i <= R;i++, j++)
            {
                arr[i] = bucket[j];
            }
        }
    }
    public static int getDigit(int x,int d)
    {
        return ((x / (int) Math.pow(10, d - 1) ) % 10);
    }

稍有一点绕需要多次看视频理解一下，“分片”的形式。