算法 | 学习笔记

小马xiaoma
90 阅读3分钟

04/19 小马

仅供个人学习记录用

排序算法

image.png

排序算法动画：

juejin.cn/post/684490…

冒泡排序 Bubble Sort

循环数组，比较当前元素和下一个元素，如果当前元素比下一个元素大，向上冒泡。下一次循环继续上面的操作，不循环已经排序好的数。

function bubbleSort(array) {
  for (let j = 0; j < array.length; j++) {
    let complete = true;
    for (let i = 0; i < array.length - j - 1; i++) {
      // 比较相邻数
      if (array[i] > array[i + 1]) {
        [array[i], array[i + 1]] = [array[i + 1], array[i]];
        complete = false;
      }
    }
    // 没有冒泡结束循环
    if (complete) {
      break;
    }
  }
  return array;
}

插入排序 Insertion Sort

将左侧序列看成一个有序序列，每次将一个数字插入该有序序列。插入时，从有序序列最右侧开始比较，若比较的数较大，后移一位。

function insertSort(array) {
  for (let i = 1; i < array.length; i++) {
    let target = i;
    for (let j = i - 1; j >= 0; j--) {
      if (array[target] < array[j]) {
        [array[target], array[j]] = [array[j], array[target]]
        target = j;
      } else {
        break;
      }
    }
  }
  return array;
}

选择排序 Selection Sort

每次排序取一个最大或最小的数字放到前面的有序序列中。

最好最坏情况复杂度都是O(n^2)

function selectionSort(array) {
  for (let i = 0; i < array.length - 1; i++) {
    let minIndex = i;
    for (let j = i + 1; j < array.length; j++) {
      if (array[j] < array[minIndex]) {
        minIndex = j;
      }
    }
    [array[minIndex], array[i]] = [array[i], array[minIndex]];
  }
}

希尔排序 Shell Sort

实质上就是插入排序的增强版，比普通版插入排序多了一个for循环；希尔排序将数组分隔成n组来进行插入排序，直至该数组宏观上有序，最后再进行插入排序时就不用移动那么多次位置了。

public static void shellSort(int[] arrays) {
    //增量每次都除以2
    for (int step = arrays.length / 2; step > 0; step /= 2) {
        //从增量那组开始进行插入排序，直至完毕
        for (int i = step; i < arrays.length; i++) {
            int j = i;
            int temp = arrays[j];
            // j - step 就是代表与它同组隔壁的元素
            while (j - step >= 0 && arrays[j - step] > temp) {
                arrays[j] = arrays[j - step];
                j = j - step;
            }
            arrays[j] = temp;
        }
    }
}

堆排序 Heapsort

  • 堆排序使用到了完全二叉树的一个特性，根节点比左孩子和右孩子都要大，完成一次建堆的操作实质上是比较根节点和左孩子、右孩子的大小，大的交换到根节点上，直至最大的节点在树顶
  • 创建一个大顶堆，大顶堆的堆顶一定是最大的元素。
  • 交换第一个元素和最后一个元素，让剩余的元素继续调整为大顶堆。
  • 从后往前以此和第一个元素交换并重新构建，排序完成。

// 来源：https://juejin.cn/post/6844903583301763085#heading-7

public static void main(String[] args) {

    int[] arrays = {6, 3, 8, 7, 5, 1, 2, 23, 4321, 432, 3,2,34234,2134,1234,5,132423, 234, 4, 2, 4, 1, 5, 2, 5};

    for (int i = 0; i < arrays.length; i++) {

        //每完成一次建堆就可以排除一个元素了(最大的在arrays[0])
        maxHeapify(arrays, arrays.length - i);

        //交换(最大的移到最后)
        int temp = arrays[0];
        arrays[0] = arrays[(arrays.length - 1) - i];
        arrays[(arrays.length - 1) - i] = temp;

    }

    System.out.println("公众号：Java3y" + arrays);

}


//   完成一次建堆，最大值在堆的顶部(根节点)

public static void maxHeapify(int[] arrays, int size) {

    for (int i = size - 1; i >= 0; i--) {
        heapify(arrays, i, size);
    }

}

/**

*   建堆
*
*   @param arrays          看作是完全二叉树
*   @param currentRootNode 当前父节点位置
*   @param size            节点总数

*/

public static void heapify(int[] arrays, int currentRootNode, int size) {

    if (currentRootNode < size) {
        //左子树和右字数的位置
        int left = 2 * currentRootNode + 1;
        int right = 2 * currentRootNode + 2;

        //把当前父节点位置看成是最大的
        int max = currentRootNode;

        if (left < size) {
            //如果比当前根元素要大，记录它的位置
            if (arrays[max] < arrays[left]) {
                max = left;
            }
        }
        if (right < size) {
            //如果比当前根元素要大，记录它的位置
            if (arrays[max] < arrays[right]) {
                max = right;
            }
        }
        //如果最大的不是根元素位置，那么就交换
        if (max != currentRootNode) {
            int temp = arrays[max];
            arrays[max] = arrays[currentRootNode];
            arrays[currentRootNode] = temp;

            //继续比较，直到完成一次建堆
            heapify(arrays, max, size);
        }
    }
}

归并排序 Merge Sort

  • 属于 external sorting
  • 将大序列二分成小序列，将小序列排序后再将排序后的小序列归并成大序列。
    • 分治法（Divide and Conquer）
  • 时间复杂度：O(nlogn)
    • 归并的过程是一个树，层数（不包括叶）是 log N
    • 每层比较的数量为 N
  • 空间复杂度:O(n)

//记录数组的索引，使用`left、right`两个索引来限定当前分割的数组。

//优点：空间复杂度低，只需一个`temp`存储空间，不需要拷贝数组

function mergeSort(array, left, right, temp) {
    if (left < right) {
        const mid = Math.floor((left + right) / 2);
        mergeSort(array, left, mid, temp)
        mergeSort(array, mid + 1, right, temp) //递归排序左右两小组
        merge(array, left, right, temp); //合并
    }
    return array;
}


function merge(array, left, right, temp) {
    const mid = Math.floor((left + right) / 2);
    let leftIndex = left; //左数组的第一位
    let rightIndex = mid + 1; //右数组的第一位
    let tempIndex = 0;
    
    //左右数组逐位比较，最小的加到temp内
    while (leftIndex <= mid && rightIndex <= right) {
        if (array[leftIndex] < array[rightIndex]) 
            temp[tempIndex++] = array[leftIndex++]
        else 
            temp[tempIndex++] = array[rightIndex++]
    }
    
    //右边数组都合并完了，左边的一定大于当前合并的数组，直接加进去
    while (leftIndex <= mid) {
        temp[tempIndex++] = array[leftIndex++]
    }
    //左边数组都合并完了，右边的一定大于当前合并的数组，直接加进去
    while (rightIndex <= right) {
        temp[tempIndex++] = array[rightIndex++]
    }
    tempIndex = 0;
    for (let i = left; i <= right; i++) {
        array[i] = temp[tempIndex++];
    }
}

快速排序 Quick Sort

  • 选择一个目标值（pivot），比目标值小的放左边，比目标值大的放右边，目标值的位置已排好，将左右两侧再进行快排。
  • 同样使用分治法（Divide and Conquer）

思路

  1. 选择一个基准元素target（一般选择第一个数）
  2. 将比target小的元素移动到数组左边，比target大的元素移动到数组右边
  3. 分别对target左侧和右侧的元素进行快速排序

image.png

方法一

  • 记录一个索引l从数组最左侧开始，记录一个索引r从数组右侧开始
  • 在l<r的条件下，找到右侧小于target的值array[r]，并将其赋值到array[l]
  • 在l<r的条件下，找到左侧大于target的值array[l]，并将其赋值到array[r]
  • 这样让l=r时，左侧的值全部小于target，右侧的值全部小于target，将target放到该位置
  • 不需要额外存储空间
function quickSort(array, start, end) {
    if (end - start < 1) {
        return;
    }
    const target = array[start];
    let l = start;
    let r = end;
    while (l < r) {
        while (l < r && array[r] >= target) {
          r--;
        }
        array[l] = array[r];
        while (l < r && array[l] < target) {
          l++;
        }
        array[r] = array[l];
    }
    array[l] = target;
    quickSort(array, start, l - 1);
    quickSort(array, l + 1, end);
    return array;
}

方法二

以第一个数字6作为基数，使用双指针i,j进行双向遍历：

  1. i从左往右寻找第一位大于基数（6）的数字，j从右往左寻找第一位小于基数（6）的数字

  2. 找到后将两个数字进行交换。继续循环交换直到i>=j结束循环

  3. 最终指针i=j, 此时交换基数和i(j)指向的数字即可将数组划分为小于基数（6）/基数（6）/大于基数（6）的三部分

image.png


public static void main(String[] args) {
        int n[] = { 6, 5, 2, 7, 3, 9, 8, 4, 10, 1 };
        quicksort(n);
        System.out.print("快排结果：");
        for (int m : n) {
                System.out.print(m + " ");
        }
}

public static void quicksort(int n[]) {
        sort(n, 0, n.length - 1);
}

public static void sort(int n[], int l, int r) {
        if (l < r) {
                // 一趟快排，并返回交换后**基数**的下标
                int index = patition(n, l, r);
                // 递归排序基数左边的数组
                sort(n, l, index - 1);
                // 递归排序基数右边的数组
                sort(n, index + 1, r);
        }

}

public static int patition(int n[], int l, int r) {
        // p为基数，即待排序数组的第一个数
        int p = n[l];
        int i = l;
        int j = r;
        while (i < j) {
                // 从右往左找第一个小于基数的数
                while (n[j] >= p && i < j) {
                        j--;
                }
                // 从左往右找第一个大于基数的数
                while (n[i] <= p && i < j) {
                        i++;
                }
                // 找到后交换两个数
                swap(n, i, j);
        }
        // 使划分好的数分布在基数两侧
        swap(n, l, i);
        return i;
}

private static void swap(int n[], int i, int j) {
        int temp = n[i];
        n[i] = n[j];
        n[j] = temp;
}

来源： 八大排序-快速排序（搞定面试之手写快排） juejin.cn/post/684490…

复杂度

  • 时间复杂度：平均O(nlogn)，最坏O(n2)，实际上大多数情况下小于O(nlogn)
  • 空间复杂度:O(logn)（递归调用消耗）

DFS 和 BFS

动态规划

贪心算法

Reference

来源/推荐阅读：

基于JavaScript的算法专题☆☆☆☆☆

www.conardli.top/docs/algori…

前端该如何准备数据结构和算法？☆☆☆☆

juejin.cn/post/684490…

八大基础排序总结

juejin.cn/post/684490…

十大经典排序算法动画

juejin.cn/post/684490…

avatar
文章
阅读
粉丝