알고리즘 연습 (1) - 기본 데이터 구조 와 찾기 알고리즘

본 고 는 간단 한 데이터 구조 와 검색 알고리즘 을 포함 하여 개인 정리 에 속한다.초학 프로 그래 밍 은 이곳 의 물건 으로 연결 할 수 있 습 니 다. 한 번 보면 재 미 있 습 니 다. 블 로 거 개인 은 js 에서 알고리즘 데이터 구조 가 중요 하지 않다 고 생각 하지 않 습 니 다. 이것 은 프로그램 개발 의 기본 적 인 기능 이기 때 문 입 니 다.본 고 는 블 로 거들 의 학습 진전 과 시간 안배 에 따라 비정 기적 으로 갱신 할 것 이다.
데이터 구조 부분
리스트

function List(){
  this.listSize = 0;
  this.pos = 0;
  this.dataStore = [];

  //  
  this.find = function(element){
    return dataStore.indexOf(element);
  };

  //    
  this.append = function(element){
    this.dataStore[this.listSize++] = element;
  };

  //    
  this.remove = function(element){
    var foundAt = this.find(element);
    if(foundAt > -1){
      this.dataStore.splice(foundAt, 1);
      --this.listSize;
      return true;
    }
    return false;
  };

  //    
  this.getLength = function(){
    return this.listSize;
  };

  //    
  this.insert = function(element, after){
    var insertPos = this.find(after);
    if(insertPos > -1){
      this.dataStore.splice(insertPos+1, 0, element);
      ++this.listSize;
      return true;
    }
    return false;
  };

  //    
  this.clear = function(){
    delete this.dataStore;
    this.dataStore.length = 0;
    this.listSize = this.pos = 0;
  };

  //         
  this.contains = function(element){
    return this.find(element) !== -1;
  };

  //      
  this.toString = function(){
    return this.dataStore.join(",");
  };

  //       
  this.front = function(){
    this.pos = 0;
  };

  //       
  this.end = function(){
    this.pos = this.listSize - 1;
  };

  //    
  this.prev = function(){
    if(this.pos > 0)
      --this.pos;
  };

  //    
  this.next = function(){
    if(this.pos < this.listSize - 1)
      ++this.pos;
  };

  //        
  this.currPos = function(){
    return this.pos;
  };

  //     posi
  this.moveTo = function(posi){
    if(posi < this.listSize && posi >= 0){
        this.pos = position;
        return true;
    }
    return false;
  };

  //          
  this.getElement = function(){
    return this.dataStore[this.pos];
  };
}

대열

function queue(){
  this.dataStore = [];

  this.enqueue = function(element){    //  
    this.dataStore.push(element);
  };
  this.dequeue = function(){    //  
    return this.dataStore.shift();
  };
  this.front(){   //    
    return this.dataStore[0];
  };
  this.back(){   //    
    return this.dataStore[this.dataStore.length - 1];
  };
  this.empty = function(){   //    
    return this.dataStore.length === 0;
  };
  this.getLength = function(){   //      
    return this.dataStore.length;
  };
}

창고.

function Stack(){
  this.dataStore = [];

  this.push = function(element){   //  
    this.dataStore.push(element);
  };
  this.peek = function(){    //    
    if(this.dataStore.length > 0)
      return this.dataStore[this.dataStore.length - 1];
    return undefined;
  };

  this.clear = function(){   //  
    this.dataStore.length = 0;
  };

  this.pop = function(){    //  
    return this.dataStore.pop();
  };

  this.getLength = function(){   //    
    return this.dataStore.length;
  };
}

체인 테이블

function Node(element){      //    
  this.element = element;
  this.next = null;
}
function LList(){
  this.head = new Node("head");

  this.find = function(item){   //  
    var currNode = this.head;
    while(currNode && currNode.element != item){
      currNode = currNode.next;
    };
    return currNode;
  };

  this.insert = function(newElement, item){    // item    
    var newNode = new Node(newElement);
    var current = this.find(item);
    if(current === null) {
      this.append(newElement);
      return false;
    }
    newNode.next = current.next;
    current.next = newNode;
    return true;
  };

  this.display = function(){   //    
    var currNode = this.head;
    while(currNode.next !== null){
      console.log(currNode.next.element);
      currNode = currNode.next;
    }
  };

  this.remove = function(element){
    var currNode = this.head;
    while(1){
      if(currNode.next === null) return false;
      if(currNode.next.element === element) break;
      currNode = currNode.next;
    }
    currNode.next = currNode.next.next;
  };
}

링 링크

function Node(element){      //    
  this.element = element;
  this.next = null;
}
function LList(){
  this.head = new Node("head");
  this.head.next = this.head;  //  

  this.find = function(item){  //  
    var currNode = this.head;
    while(currNode.element != item){
      if(currNode.next === this.head) return null;
      currNode = currNode.next;
    };
    return currNode;
  };

  this.insert = function(newElement, item){   // item    
    var newNode = new Node(newElement);
    var current = this.find(item);
    newNode.next = current.next;
    current.next = newNode;
  };

  this.display = function(){   //    
    var currNode = this.head;
    while(currNode.next !== this.head){
      console.log(currNode.next.element);
      currNode = currNode.next;
    }
  };

  this.remove = function(element){    //  
    var currNode = this.head;
    while(1){
      if(currNode.next == this.head) return false;
      if(currNode.next.element == element) break;
      currNode = currNode.next;
    }
    currNode.next = currNode.next.next;
  };
}

양 방향 링크

function Node(element){
  this.element = element;
  this.next = null;
  this.previous = null;
}
function LList(){
  this.head = new Node("head");
  this.tail = this.head;

  this.find = function(item){   //  
    var currNode = this.head;
    while(currNode.element != item){
      if(currNode.next === null) return null;
      currNode = currNode.next;
    };
    return currNode;
  };

  this.insert = function(newElement, item){   // item    
    var newNode = new Node(newElement);
    var current = this.find(item);
    newNode.next = current.next;
    current.next = newNode;
    current.next.previous = newNode;
    newNode.previous = current;
  };

  this.display = function(){   //    
    var currNode = this.head;
    while(currNode.next !== null){
      console.log(currNode.next.element);
      currNode = currNode.next;
    }
  };

  this.remove = function(item){   //  
    var currNode = this.find(item);
    if(currNode){
      currNode.previous.next = currNode.next;
      currNode.next.previous = currNode.previous;
      currNode.next = null;
      currNode.previous = null;
      return true;
    }
    return false;
  };

  this.dispReverse = function(){   //    
    var currNode = this.tail;
    while(currNode.previous !== null){
      console.log(currNode.element);
      currNode = currNode.previous;
    }
  };
}

자전.

function dictionary(){
  this.dataStore = [];

  this.add = function(key, value){  //  
    if(this.find(key)) console.log("'" + key + "' exists");
    else this.dataStore[key] = value;
  };

  this.find = function(key){   //  
    return this.dataStore[key];
  };

  this.remove = function(key){   //  
    delete this.dataStore[key];
  };

  this.showAll = function(){   //    
    var keys = Object.keys(this.dataStore).sort();
    keys.forEach(function(key){
      console.log(key + " -> " + this.dataStore[key]);
    });
  };

  this.count = function(){   //  
    return Object.keys(this.dataStore).length;
  };

  this.clear = function(){   //  
    for(var k in this.dataStore){
      if(dataStore.hasOwnPorperty(k)){
        delete this.dataStore[k];
      }
    }
  };
}

집합 하 다.

function Set(){
  this.dataStore = [];

  this.add = function(data){   //  
    if(this.dataStore.indexOf(data) < 0){
      this.dataStore.push(data);
      return true;
    } else return false;
  };

  this.show = function(){  //  
    console.log(this.dataStore.join(","));
  };

  this.remove = function(data){   //  
    var pos = this.dataStore.indexOf(data);
    if(pos > -1){
      this.dataStore.splice(pos, 1);
      return true;
    } else return false;
  };

  this.size = function(){  //        (    )
    return this.dataStore.length;
  };
  this.contains = function(data) {    //    data
    return this.dataStore.indexOf(data) > -1;
  };

  this.clone = function(){   //      
    var tempSet = new Set();
    for(var i = 0; i < this.size(); ++i)
      tempSet.add(this.dataStore[i]);
    return tempSet;
  };

  this.union = function(set){   //   
    var tempSet = this.clone();
    for(var i = 0; i < set.size(); ++i){
      if(!tempSet.contains(set.dataStore[i]))
        temp.dataStore.push(set.dataStore[i]);
    }
    return tempSet;
  };

  this.interSect = function(set){   //   
    var tempSet = new Set();
    for(var i = 0; i < this.size(); ++i){
      if(set.contains(this.dataStore[i]))
        tempSet.add(this.dataStore[i]);
    }
    return tempSet;
  };

  this.subSet = function(set){    //        set   
    if(this.size() > set.size()) return false;
    else{
      for(var i = 0; i < this.size(); ++i){
        if(!set.contains(this.dataStore[i]))
          return false;
      }
    }
    return true;
  };

  this.difference = function(set){   //    this-set
    var tempSet = new Set();
    for(var i = 0; i < this.dataStore.length; ++i){
      if(!set.contains(this.dataStore[i]))
        tempSet.add(this.dataStore[i]);
    }
    return tempSet;
  };
}

해시 시계

function HashTable(){
  this.table = [];

  //this.values = [];

  // key             simpleHash
  this.simpleHash = function(data){   //          
    var total = 0;
    for(var i = 0; i < data.length; ++i)
      total += data.charDodeAt(i);
    return total % this.table.length;
  };

  //simpleHash()        ：           hash ，  "Raymond" "Clayton"。        (hashing collision)

  this.betterHash = function(string, arr){
    const H = 31;    //      
    var total = 0;
    for(var i = 0; i < string.length; ++i)
      total += H * total + string.charCodeAt(i);
    total = total % arr.length;
    return parseInt(total);
  };


  this.showDistro = function(){
    var n = 0;
    for(var i = 0; i < this.table.length; ++i){
      // if(this.table[i] !== undefined) //         if
      if(this.table[i][0] !== undefined)    //       if
        console.log(i + ": " + this.table[i]);
    }
  };

  //     betterHash，                   ，        (separate chaining)      (linear probing)
  //    
  this.buildChains = function(){
    for(var i = 0; i < this.table.length; ++i)
      this.table[i] = [];
  };

  //     put  
  this.put = function(data){
    var pos = this.betterHash(data);
    var index = 0;

    if(this.table[pos][index] === undefined)
      this.table[pos][index] = data;
    else {
      while(this.table[pos][index] !== undefined) ++index;
      this.table[pos][index] = data;
    }
  };

  //     get  
  this.get = function(key){
    var pos = this.betterHash(key);
    var index = 0;
    if(this.table[pos][index] === key)
      return this.table[pos][index + 1];
    else {
      while(this.table[pos][index] !== key) index += 2;
      return this.table[pos][index + 1];
    }
    return undefined;
  };

  /* //       put   this.put = function(key, data){ var pos = this.betterHash(data); if(this.table[pos] == undefined){ this.table[pos] = key; this.values[pos] = data; } else { while(this.table[pos] != undefined) ++pos; this.table[pos] = key; this.values[pos] = data; } }; //       get   this.get = function(key){ var hash = -1; hash = this.betterHash(key); if(hash > -1){ for(var i = hash; this.table[hash] != undefined; ++i){ if(this.table[hash] == key) return this.values[hash]; } } }; */
}

나무.

function Node(data, left, right){   //   
  this.data = data;
  this.left = left;
  this.right = right;
  this.show = function(){ return this.data; };
}

//         (Binary Search Tree)
function BST(){
  this.root = null;

  this.insert = function(data){
    var n = new Node(data, null, null);
    if(this.root === null) {
      this.root = n;
    }
    else{
      var current = this.root;
      var parent;
      while(true){
        parent = current;
        if(data < current.data){
          current = current.left;
          if(current === null){
            parent.left = n;
            break;
          }
        }
        else{
          current = current.right;
          if(current == null){
            parent.right = n;
            break;
          }
        }
      }
    }
  };

  //    
  this.inOrder = function(node){
    if(node !== null){
      inOrder(node.left);
      console.log(node.show() + " ");
      inOrder(node.right);
    }
  };

  //    
  this.preOrder = function(node){
    if(node !== null){
      console.log(node.show() + " ");
      preOrder(node.left);
      preOrder(node.right);
    }
  };

  //    
  this.postOrder = function(node){
    if(node !== null){
      postOrder(node.left);
      postOrder(node.right);
      console.log(node.show() + " ");
    }
  };

  //    
  this.getMin = function(){
    var current = this.root;
    while(current.left !== null)
      current = current.left;
    return current.data;
  };

  //    
  this.getMax = function(){
    var current = this.root;
    while(current.right !== null)
      current = current.right;
    return current.data;
  };

  //   
  function find(data){
    var current = this.root;
    while(current !== null){
      if(current.data == data) return current;
      else if(data < current.data) current = current.left;
      else if(data > current.data) current = current.right;
    }
    return null;
  };

  //   
  this.removeData = function(data){
    this.root = removeNode(this.root, data);
    function removeNode(node, data){
      if(node === null) return null;
      if(data === node.data){
        if(node.left == null && node.right == null) return null;
        if(node.left == null) return node.right;
        if(node.right == null) return node.left;
        var tempNode = getSmallest(node.right);
        node.data = tempNode.data;
        node.right = removeNode(node.right, tempNode.data);
        return node;
      }
      else if(data < node.data){
        node.left = removeNode(node.left, data);
        return node;
      } else{
        node.right = removeNode(node.right, data);
        return node;
      }
    }
  };
}

그림.

function Graph(v_num){
  this.vertices = v_num;    //    
  this.edges = 0;       //    
  this.adj = [];        //    
  this.marked = [];     //            
  this.vertexList = []; //    
  this.edgeTo = [];     //        ，    

  for(var i = 0; i < this.vertices; ++i){    //       
    this.adj[i] = [];
    this.adj[i] = push("");
  }

  this.addEdge = function(v, w){   //   ,  2  
    this.adj[v].push(w);
    this.adj[w].push(v);
    this.edges++;
  };

  this.showGraph = function(){    //   
    for(var i = 0; i < this.vertices; ++i){
      console.log(i + " -> ");
      for(var j = 0; j < this.vertices; ++j){
        if(this.adj[i][j] !== undefined)
          console.log(this.adj[i][j] + " ");
      }
      console.log("
");
    }
  };

  //      
  this.dfs = function(v){
    for(var i = 0; i < this.vertices; ++i)   //       
      this.mark[i] = false;
    innerDfs(v);

    function innerDfs(v){
      this.marked[v] = true;
      if(this.adj[v] !== undefined)
        console.log(v + " ");
      for(var i = 0; i < this.adj[v].length; ++i){
        var ver = this.adj[v][i];
        if(!this.marked[ver]) this.innerDfs(ver);
      }
    }
  };

  //      
  this.bfs = function(s){
    for(var i = 0; i < this.vertices; ++i)   //       
      this.mark[i] = false;
    var queue = [];     //        
    this.marked[s] = true;
    queue.push(s);
    while(queue.length > 0){
      var v = queue.shift();
      if(v !== undefined) console.log(s + "");
      for(var i = 0; i < this.adj[v].length; ++i){
        var ver = this.adj[v][i];
        if(!this.marked[ver]){
          this.edgeTo[ver] = v;
          this.marked[ver] = true;
          queue.push(ver);
        }
      }
    }
  };

  this.hasPathTo = function(v){   //        v   
      return this.marked[v];
  };

  this.showPath = function(){     //    
    while(paths.length > 0){
      if(paths.legnth > 1) console.log(paths.pop() + '-');
      else console.log(paths.pop());
    }
  };

  this.pathTo = function(v) {    //  path  
    var path = [];
    var source = 0;
    if(!this.hasPathTo(v))
      return undefined;
    for(var i = v; i !== source; i = this.edgeTo[i])
      path.push(i);
    path.push(source);
    return path;

  };

  //    
  this.topologicalSort = function(){

    var stack = [];     // 
    var visited = [];   //       
    //   
    for(var i = 0; i < this.vertices; ++i)
      visited = false;

    for(var i = 0; i < this.vertices; ++i){
      if(!visited[i])
        this.topSortHelper(i, visited);  //          
    }

    for(var i = 0; i < stack.length; ++i){
      if(stack[i] !== undefined && stack[i] !== false)
        console.log(this.vertexList[stack[i]]);
    }

    function topSortHelper(v, visited){
      visit[v] = true;
      for(var i = 0; i < this.adj[v].length; ++i){
        var w = this.adj[v][i];
        if(!visited[w])
          this.topSortHelper(visited[w], visited);  //           
      }
      stack.push(v);
    }
  };
}

관련 알고리즘 찾기
순서 찾기

function seqSearch(arr, data){
  for(var i = 0; i < arr.length; i++){ if(arr[i] == data) return i; }
  return -1;
}

이분 찾기

//  arr       
function binSearch(arr, data){
  var upperBound = arr.length - 1;
  var lowerBound = 0;
  while(lowerBound <= upperBound){
    var mid = Math.floor((upperBound + lowerBound) / 2);
    if(arr[mid] < data) lowerBound = mid + 1;
    if(arr[mid] > data) upperBound = mid - 1;
    if(arr[mid] == data) return mid;
  }
  return -1;
}

//        
//  arr       
function count(arr, data){
  var count = 0;
  var pos = binSearch(arr, data);
  if(pos > -1){
    ++count;
    for(var i = pos - 1; i > 0; --i){
      if(arr[i] == data) ++count;
      else break;
    }
    for(var i = pos + 1; i < arr.length; ++i){
      if(arr[i] == data) ++count;
      else break;
    }
  }
  return count;
}

두 갈래 찾기 트 리
본 논문 의 데이터 구조 부분 인 나무의 부분 이 이미 실현 되 었 다.
해시 찾기
본 논문 의 데이터 구조 부분 인 해시 표 부분의 get () 방법 은 이미 실현 되 었 다.
플러그 인 찾기

function insertionSearch(arr, value){
  return insertionSearchHelper(arr, value, 0, arr.length);

  function insertionSearchHelper(arr, value, low, high){
    var mid = low + (value - arr[low]) / (arr[high] - arr[low]) * (high - low);

    if(arr[mid] === value)
      return mid;
    if(arr[mid] > value)
      return InsertionSearchHelper(arr, value, low, mid-1);
    if(arr[mid] < value)
      return InsertionSearchHelper(arr, value, mid+1, high);
    return null;
  }
}

모든 검색 알고리즘 정리 시간 복잡 도
최 악의 경우
가장 좋 은 상황 에서
질 서 를 요구 하 는 지 여부
찾다
끼어들다
삭제
찾다
끼어들다
삭제
순서 구조
N
N
N
N2
N
N2
No
이분 알고리즘
logN
N
N
logN
N2
N2
Yes
두 갈래 찾기 트 리 (BST)
N
N
N
1.39logN
1.39logN
N‾‾√
Yes
2 - 3 나무
clogN
clogN
clogN
clogN
clogN
clogN
Yes
검 붉 은 나무
2logN
2logN
2logN
logN
logN
logN
Yes
해시 해시 해시 찾기
logN
logN
logN
3~5
3~5
3~5
No
해시 프로 브 찾기
logN
logN
logN
3~5
3~5
3~5
No
평균 길이 찾기 (ASL) = 테이블 의 i 번 째 요소 찾기 확률 (Pi) * i 번 째 요 소 를 찾 았 을 때 비교 한 횟수 (Ci)