数据结构和算法面试常见题必考以及前端面试题

public class Node {
    public int value;
    public Node next;
}

public Node reverseList(Node head) {
    Node pre = null;
    Node next = null;
    while (head != null) {
        next = head.next;
        head.next = pre;
        pre = head;
        head = head.next
    }
    return pre;
}

private int binarySearch(int[] arr, int searchKey) {
  if (arr == null) {
    return -1;
  }
  int n = arr.length;
  int left = 0;
  int right = n - 1;
  while (left <= right) {
    int mid = left + ((right -left) >> 1);
    if (arr[mid] > searchKey) {
      right = mid - 1;
    } else if (arr[mid] < searchKey) {
      left = mid + 1;
    } else {
      return mid;
    }
  }
  return -1;
}

private int binarySearchRecursive(int[] arr, int left, int right) {
  if (arr == null) {
    return -1;
  }
  int n = arr.length;
  int left = 0;
  int right = n -1;
  while (left <= right) {
    int mid = left + ((right - left) >> 1);
    if (arr[mid] > searchKey) {
      binarySearchRecursive(arr, left, mid - 1);
    } else if (arr[mid] < searchKey) {
      binarySearchRecursive(arr, mid + 1, right);
    } else {
      return mid;
    }
  }
  return -1;
}

private int getDepth(Node node) {
  if (node == null) {
    return 0;
  }
  int left = getDepth(node.left);
  int right = getDepth(node.right);
  return left > right ? (left + 1) : (right + 1);
}

function getTimes(arr, key) {
    var n = arr.length;
    var hash = {};
    for (var i = 0; i < n; i ++) {
        var ele = arr[i];
        if (!hash[ele]) {
            hash[ele] = 1;
        } else {
            hash[ele] ++;
        }
    }
    if (hash[key]) {
        return hash[key];    
    } else {
        return -1;
    }
}

    private static void stasTimes(int[] arr, int key) {
        int len = arr.length;
        HashMap<Integer, Integer> hash = new HashMap<Integer, Integer>();
        for (int i =0; i < len; i++) {
            if (hash.containsKey(arr[i])) {
                Integer val = hash.get(arr[i]) + 1;
                hash.put(arr[i], val);
            } else {
                hash.put(arr[i], 1);
            }
        }
        for (Integer hashKey: hash.keySet()) {
            if (hashKey.intValue() == key) {
                System.out.println(key + " has appeared " + hash.get(hashKey) + " times");
            }
        }
    }

private char[] moveChar(String str, char a) {
  char[] arr = str.toCharArray();
  int i = arr.length - 1;
  while (arr[i] != a) {
    i --;
  }
  for (int j = i - 1; j >= 0; j --) {
    if (arr[j] != a) {
      arr[i] = arr[j];
      arr[j] = a;
      i --;
    }
  }
  return arr;
}

public static void bubbleSort(int[] arr) {
  if (arr == null || arr.length == 0) {
    return;
  }
  for (int i = 0; i < arr.length - 1; i++) {
    for (int j = 0; j < arr.length - 1 - i; j++) {
      if (arr[j] > arr[j+1]]) {
        swap(arr, j+1, j);
      }
    }
  }
}
public static void swap(int[] arr, int i, int j) {
  int temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
}

interface User {
  name: string,
  age: number
}

insterface SetUser {
  (name: string, age: number) : void;
}


type SetUser = (name: string, age: number) => void;

// 都允许扩展


// interface extends type

type Name = {
  name: string;
}

instance

// type 不是一个类型，它是类型别名
 // type 可以声明基本类型别名，联合类型，元祖等类型
 // 基本类型别名
 type Name = string


// interface 可以 而type不行

// interface 能够声明合并
interface User {
  name: string,
  age: number
}
interface User {
  sex: string
}

new Error 不会终止成员运行

async function f() {
  console.log(1)
  await new Promise((resolve, reject) => {
    console.log(2)
    throw new Error('出错了')
  }).catch(err => {
    console.log(3)
    console.log('执行失败了')
  })
  console.log(4)
}
// 1234

async function f() {
  try {
    // await new Promise((resolve, reject) => {
    //   // throw new Error('出错了')
    //   resolve()
    // })
    await new Promise((resolve, reject) => {
      throw new Error('出错了')
    })
    
    console.log('正常输出')
  } catch (err) {
    // 这里用来捕获异常
    console.log('异常了)
  }
}

async function Login () {
  // 接口请求异常， 
  // 用户名错误、密码错误、用户不存在、500
  // 前提条件： 接口把所有的异常都通过HTTp状态吗来返回
  // 尤其是在使用axios 请求库的时候， 它会把所有超出200- 300范围的状态码捕获
  try {
     catch (err) {

     }
  }
}

try {
  const p = new Promise((resolve, reject) => {
    throw new Error('error')
    fs.readFile('./login.js', (err, data) => {
      if (err) {
        reject(err)
      } else {
        resolve(data)
      }
    })
  })
  // 这样可以捕获到
  // p.then(data => {
  //   console.log(data)
  // }).catch (err => {
  //   console.log('手动 调用catch 捕获异常')
  // })
} catch (err) {
  console.log('失败了')
}

// 没有错误