基础排序、二分查找汇总

一、常见排序算法复杂度和稳定性

二、js代码实现和思路

(1)冒泡排序:从数组起始位置两两比较,前一个大于后一个就交换位置,第一轮比较后最大的那个数就排到了最后,循环比较数组长度-1次

function bubble (arr) {  for (let j = 0; j < arr.length - 1; j++) {    for (let i = 0; i < arr.length - 1 - j; i++) {      if (arr[i] > arr[i + 1]) {        [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]]      }    }  }  return arr}

(2)选择排序:依次找出数组中最小,第二小...的数,放在arr[0],arr[1],...的位置

function selectSotr(arr) {  for (let i = 0; i < arr.length - 1; i++) {    for (let j = i + 1; j < arr.length; j++) {      if (arr[j] < arr[i]) {        [arr[i], arr[j]] = [arr[j], arr[i]]      }    }  }  return arr}

(3)插入排序:类比打扑克牌,开辟一个新的数组就好比左手已整理的牌,右手取牌将其插入合适位置

function insert (arr) {
  let arr1 = []
  arr1.push(arr[0])
  for (let i = 1; i < arr.length; i++) {
    for (let j = arr1.length - 1; j >= 0; j--) {
      if (arr[i] > arr1[j]) {
        arr1.splice(j + 1, 0, arr[i])
        break
      }
      if (arr1[0] > arr[i]) {
        arr1.unshift(arr[i])
      }
    }
  }
  return arr1
}

(4)快速排序:选取一个基准点,使用两个数组分别放入比基准点小和比基准点大的项,递归 (数组原本有序或者完全倒序时快排效率最低)

function quickSort (arr) {
  let len = arr.length
  if (len < 2) return arr
  let flag = arr[0]
  let left = []
  let right = []
  for (let i = 1; i < len; i++) {
    if (arr[i] < flag) {
      left.push(arr[i])
    } else {
      right.push(arr[i])
    }
  }
  return quickSort(left).concat(flag, quickSort(right))
}

(5)二分查找:顾名思义先选取数组中间位置和要查找项比较,每次查找范围减半


function half (arr, item) {  let begin = 0  let end = arr.length

  while (begin <= end) {    let mid = Math.floor((begin + end) / 2)    if (arr[mid] > item) {      end = mid - 1    } else if (arr[mid] < item) {      begin = mid + 1    } else {      return mid    }  }  return -1}
 
 

原文地址:https://www.cnblogs.com/ccj9697/p/11302258.html

时间: 2024-11-05 21:46:31

基础排序、二分查找汇总的相关文章

算法——基础篇——二分查找

     二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好:其缺点是要求待查表为有序表,且插入删除困难.因此,折半查找方法适用于不经常变动而查找频繁的有序列表.     首先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功:否则利用中间位置记录将表分成前.后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表.重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找不成功

Python 迭代器&amp;生成器,装饰器,递归,算法基础:二分查找、二维数组转换,正则表达式,作业:计算器开发

本节大纲 迭代器&生成器 装饰器  基本装饰器 多参数装饰器 递归 算法基础:二分查找.二维数组转换 正则表达式 常用模块学习 作业:计算器开发 实现加减乘除及拓号优先级解析 用户输入 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )等类似公式后,必须自己解析里面的(),+,-,*,/符号和公式,运算后得出结果,结果必须与真实的计算器所得出的结果一致 迭代器&

8.8 冒泡排序 选择排序 二分查找 递归使用

冒泡排序: #include <stdio.h> #include <stdlib.h> #include <time.h> #define N 100000 #define M 100000 void show_arr(int * a,int n) { int i; for(i = 0; i < n; i++) { printf("%d ",a[i]); } printf("\n"); } void init_arr(in

uva 10763 Foreign Exchange(排序+二分查找)

这道题是我第一次算出来应该用什么复杂度写的题,或许是这一章刚介绍过,500000的数据必须用nlogn,所以我就 想到了二分,它的复杂度是logn,再对n个数据进行遍历,正好是nlogn,前两次TLE了,然后我就对我的做法没信心 了...看到一篇博客上说就应该这种方法,然后我就坚定的改自己的算法去了,哈哈,专注度没有达到五颗星,最多 三颗... 思路: 我用的是结构体保存的,先对每一对序列排序,然后对第二个元素在第一个元素中二分搜索,用到了 lower_bound,upper_bound,注释里

I Count Two Three(打表+排序+二分查找)

I Count Two Three 二分查找用lower_bound 这道题用cin,cout会超时... AC代码: 1 /* */ 2 # include <iostream> 3 # include <cstring> 4 # include <string> 5 # include <cstdio> 6 # include <cmath> 7 # include <algorithm> 8 using namespace st

noi题库(noi.openjudge.cn) 1.11编程基础之二分查找T01、02、04

T01 查找最接近的元素 描述 在一个非降序列中,查找与给定值最接近的元素. 输入 第一行包含一个整数n,为非降序列长度.1 <= n <= 100000.第二行包含n个整数,为非降序列各元素.所有元素的大小均在0-1,000,000,000之间.第三行包含一个整数m,为要询问的给定值个数.1 <= m <= 10000.接下来m行,每行一个整数,为要询问最接近元素的给定值.所有给定值的大小均在0-1,000,000,000之间. 输出 m行,每行一个整数,为最接近相应给定值的元素

堆排序(选择排序)-八大排序三大查找汇总(2)

二叉堆的定义 二叉堆是完全二叉树或者是近似完全二叉树. 二叉堆满足二个特性: 1.父结点的键值总是大于或等于(小于或等于)任何一个子节点的键值. 2.每个结点的左子树和右子树都是一个二叉堆(都是最大堆或最小堆). 当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆.当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆.下图展示一个最小堆: 堆的存储 一般都用数组来表示堆,i结点的父结点下标就为(i – 1) / 2.它的左右子结点下标分别为2 * i + 1和2 * i + 2.如

归并排序-八大排序三大查找汇总(7)

基本思想 归并排序简单的说就是递归后合并,该算法是分治法(Divide and Conquer)的一个典型应用. 基本思想为:将待排序序列R[0...n-1]看成是n个长度为1的有序序列,两两有序表成对归并,得到n/2个长度为2的有序表:将这些有序序列再次归并,如此反复进行下去,最后得到一个长度为n的有序序列. 综上可知: 归并排序其实要做两件事: (1)“分解”——将序列每次折半划分. (2)“合并”——将划分后的序列段两两合并后排序. 性能 排序类别 排序方法 时间复杂度 空间复杂度 稳定性

简单选择排序(选择排序)-八大排序三大查找汇总(1)

工作原理: 每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完. 稳定性: 选择排序是不稳定的排序方法(比如序列[5, 5, 3]第一次就将第一个[5]与[3]交换,导致第一个5挪动到第二个5后面). 时间复杂度: 比较次数O(n^2),比较次数与关键字的初始状态无关,总的比较次数N=(n-1)+(n-2)+...+1=n*(n-1)/2. 交换次数O(n),最好情况是,已经有序,交换0次:最坏情况下,即待排序记录初始状态是按第一条记录最大