数据结构和常用算法

一、力扣常用算法题：

a、合并两个有序列表：两个升序的列表，进行合并成一个升序链表，可以使用双指针，判断元素大小来移动指向；

b、删除排序链表中的重复元素：使用指针，如果重复则调到下一个元素，指向下一个元素；

c、判断链表是否是环形链表：通过Floyd解法，通过双指针快、慢指针移动2/1节点，总会相遇，则为环形链表；

d、相交链表，假设不存在环，找到相交节点：使用双指针，只要到达了最后一个节点，就把这个指针交换到另一个链表上重新开始判断，总会相遇则找到相交节点；

栈（堆栈）：后进先出，LIFO结构

队列：先进先出，   FIFO结构

1、内存限制1G，快速判断一个整数是否存在40亿整数中？

     申请43亿大小的二进制位数组；对磁盘文件中的40亿进行预处理 O(n)；拿到要判断的整数，将它作为索引，去查看它对应的二进制位值；

2、

二、排序算法

冒泡算法：循环依次一个一个的交换排序 小的放左边，大的放右边。

public class BubbleSort {
    public static void main(String[] args) {
        int[] array = new int[] { 12, 2, 3, 23, 5, 6, 7, 8, 9, 10 };
        int temp = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length - 1; j++) {
                if (array[j] > array[j + 1]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }
}

选择排序：从头至尾扫描序列，找出最小的一个元素，和第一个元素交换，接着从剩下的元素中继续这种选择和交换方式，最终得到一个有序序列。

public class ChoiceSort {
    public int[] sortArray(int[] nums){
        if(nums.length == 0)
            return nums;
        for (int i=0; i< nums.length; i++){
            int minIndex = i; //最小数的下标，每个循环开始总是假设第一个数最小
            for (int j=i; j< nums.length; j++){
                if(nums[j] < nums[minIndex])//找到最小数
                    minIndex = j;//将最小数的索引保存
            }
            //交换最小数和i当前所指的元素
            int temp = nums[i];
            nums[i] = nums[minIndex];
            nums[minIndex] = temp;
            /*int temp = nums[minIndex];
            nums[minIndex] = nums[i];
            nums[i] = temp;*/
        }
        return nums;
    }
    public static void main(String[] args) {
        int[] array = new int[] { 12, 2, 3, 23, 5, 6, 7, 8, 9, 10 };
        int[] dest = new ChoiceSort().sortArray(array);
        System.out.println(Arrays.toString(dest));
    }
}

插入排序：通过构建构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

public class InsertSort {

    public int[] sortArray(int[] nums){
        if(nums.length == 0)
            return nums;
        int currentVal;//当前待排序数据，该元素之前的元素均已被排序过
        for (int i=0; i< nums.length-1; i++){
            int preIndex = i;//已被排序数据的索引
            currentVal = nums[preIndex+1];//当前待排序数据
            //在已被排序过数据中倒序寻找合适的位置，如果当前待排序数据比比较的元素要小，将比较的元素元素后移一位
            while(preIndex >= 0 && currentVal < nums[preIndex]){
                nums[preIndex+1] = nums[preIndex];
                preIndex--;
            }
            //while循环结束时，说明已经找到了当前待排序数据的合适位置，插入
            nums[preIndex+1] = currentVal;
        }
        return nums;
    }
    public static void main(String[] args) {
        int[] array = new int[] { 12, 7, 3, 23, 5, 6, 37, 8, 9, 10 };
        int[] dest = new InsertSort().sortArray(array);
        System.out.println(Arrays.toString(dest));
    }
}

希尔排序：针对插入排序算法改进，把待排序的数列分为多个组，然后再对每个组进行插入排序，先让数列整体大致有序，然后多次调整分组方式，使序列更加有序，最后再使用一次插入排序，整个数列将全部有序。

public class ShellSort {
    public int[] sortArray(int[] nums){
        if(nums.length == 0)
            return nums;
        int len = nums.length;
        //按增量分组后，每个分组中，temp代表当前待排序数据，该元素之前的组内元素均已被排序过
        //gap指用来分组的增量，会依次递减
        int currentValue, gap = len/2;
        while (gap > 0){
            for (int i = gap; i < len; i++){
                currentValue = nums[i];
                //组内已被排序数据的索引
                int preIndex = i - gap;
                //在组内已被排序过数据中倒序寻找合适的位置，如果当前待排序数据比比较的元素要小，则将比较的元素在组内后移一位
                while (preIndex >= 0 && nums[preIndex] > currentValue){
                    nums[preIndex + gap] = nums[preIndex];
                    preIndex -= gap;
                }
                //while循环结束时，说明已经找到了当前待排序数据的合适位置，插入
                nums[preIndex + gap] = currentValue;
            }
            gap /= 2;
        }
        return nums;
    }
    public static void main(String[] args) {
        int[] array = new int[] { 12, 7, 3, 23, 5, 6, 37, 8, 9, 10 };
        int[] dest = new ShellSort().sortArray(array);
        System.out.println(Arrays.toString(dest));
    }
}

快速排序：先从数列中取出一个元素作为基准数；扫描数列。将比基准数小的元素全部放到它的左边，大于或等于基准数的元素全部放到它的右边，得到左右两个区间；再对左右区间重复第二步，直到各区间少于两个元素。

归并排序：将已经有序的子数列合并，得到另一个有序的数列。也是合并排序。（相对于双指针）

堆排序：利用堆这种数据结构而设计的一种排序算法，堆具备以下特点：

      1、完全二叉树

      2、二叉树每个结点的值都大于或等于其左右子树结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆；

计数排序：

桶排序：

基数排序：