js循环队列

 

export default class MyCircularQueue{
  constructor (k){
    //用来保存数据长度为k的数据结构
    this.list=Array(k)
    this.front=0//队首的指针
    this.rear=0 //队尾的指针
    this.max=k //队列的长度
  }
  enQueue(num){
    if(this.isFull()){
      return false
    }else{
      this.list[this.rear]=num
      this.rear=(this.rear+1)%this.max
      return true
    }
  }
  deQueue(){
    let v=this.list[this.front]
    this.list[this.front]=''
    this.front=(this.front+1)%this.max
    return v
  }
  isEmpty(){
    return this.front===this.rear&&!this.list[this.front]
  }
  isFull(){
    return this.front===this.rear&&!!this.list[this.front]
  }
  Front(){
    return this.list[this.front]
  }
  Rear(){
    let rear=this.rear-1
    return this.list[rear<0?this.max-1:rear]
  }
}

　　

 

 

export default(tasks,n)=>{
  //表示最终队列执行的结果
  let q=''
  //对归类进行存储
  let Q={}
  tasks.forEach(item=>{
    if(Q[item]){
      Q[item]++
    }else{
      Q[item]=1
    }
  })
  while(1){
    // 任务清单
    let keys=Object.keys(Q)
    if(!keys[0]){
      break
    }
    //声明一个队列用来存储1+n任务单元
    let tmp=[]
    for(let i=0;i<=n;i++){
      let max=0
      let key
      let pos
      keys.forEach((item,idx)=>{
        if(Q[item]>max){
          max=Q[item]
          key=item
          pos=idx
        }
      })
      if(key){
        temp.push(key)
        keys.splice(pos,1)
        Q[key]--
        if(Q[key]<1){
          delete Q[key]
        }  
      }else{
        break
      }
    }
    q+=tmp.join('').padEnd(n+1,'-')
  }
  //边界的处理，最后不要出现冷却时间
  q=q.replace(/-+$/g,'')
  return q.length
}

　　排序的复杂度：

 

 排序链表：

 

 快速排序：

 

 链表实现

//声明链表的节点
class Node{
  constructor(value){
    this.val=value
    this.next=undefined
  }
}

//声明链表的数据结构
class NodeList{
  constructor(arr){
    //声明链表的头部节点
    let head=new Node(arr.shift())
    let next
    arr.forEach(item=>{
      next.next=new Node(item)
      next=next.next
    })
    return head
  }
}

//交换两个节点的值
let swap=(p,q)=>{
  let val=p.val
  p.val=q.val
  q.val=val
}

//寻找基准元素的节点
let partion=(begin,end)=>{
  let val=begin.val
  let p=begin
  let q=begin.next
  while(q!==end){
    if(q.val<val){
      p=p.next
      swap(p,q)
    }
    q=q.next
  }
  //让基准元素跑到中间去
  swap(p,begin)
  return p
}

export default function sort(begin,end){
  if(begin!==end){
    let part=partion(begin,end) //找基准元素
    sort(begin,end)
    sort(part.next,end)
  }
}

　　循环链表：