nodejs数据结构（acm模式）

大部分机试是acm模式，但leetcode是核心代码格式。

注意输入输出。
javascript node 模式

（一）输入输出

单行输入

var readline = require('readline');
const rl = readline.createInterface({ 
	input: process.stdin, 
	output: process.stdout });
rl.on('line', function(line){ 
	var tokens = line.split(' '); //获取第一行内容，存为数组 
	console.log(parseInt(tokens[0]) + parseInt(tokens[1]));
 });

多行输入，固定行输入

var readline = require('readline'); 
const rl = readline.createInterface({ 
	input: process.stdin, 
	output: process.stdout 
}); //固定行数的多行输入 
const lines = []; 
var num=3; //设定输入行数 
var rows=[]; //用于存储每行的输入 
rl.on('line',function(data){ 
	rows.push(data); //将每次输入的行数据存入 
	if(num === rows.length){ //输入的行数等于num值 
		console.log(rows); //输出结果
	} 
});

多行输入，第一行是接下来输入数据的行数

const readline = require('readline');
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});
var k=-1; //先给行数置-1,表示还没开始读取
var rows=[]; //用于存储每行的输入
rl.on('line',function(line){
    if(k<0){
        k=parseInt(line.trim()); //读取第一行，得到接下来输入的行数
    }else{
        rows.push(line.trim()); //将每次输入的行数据存入
        if(k==rows.length){ //当输入的行数等于设定的k值时，开始逻辑处理
			console.log(rows); //输出结果
        }
        
    }
});

（二）数组与链表

1，数组转链表
2，链表转数组

function ListNode(x) {
    this.val = x
    this.next = null
}
//数组转链表
function arrayToNodeList(list) {
    let header = new ListNode(0)
    let current = header
    for (let i = 0; i < list.length; i++) {
        current.next = { val: list[i], next: null }
        current = current.next
    }
    return header.next
}

//链表转数组
function nodeListToArray(node) {
    const list = []
    let header = node
    while (header) {
        list.push(header.val)
        header = header.next
    }
    return list
}

（三）数组与二叉树

数组转二叉树

function TreeNode(val, left, right) {
    this.val = (val === undefined) ? 0 : val;
    this.left = (left === undefined) ? null : left;
    this.right = (right === undefined) ? null : right;
}
//数组转为二叉树
function buildTree(val_list) {
    // 数组为空
    if (!val_list || val_list.length === 0) {
        return;
    }
    // 根节点
    var root = new TreeNode(val_list.shift());

    var nodeQueue = [root];
    // 对root节点进行操作，更新node
    while (val_list.length > 0) {
        var node = nodeQueue.shift();
        // n = node.level + 1;	// 获取父节点的层级，子节点在该层级上+1
        // 构建：左孩子节点
        if (val_list.length === 0) {
            break;
        }
        var leftVal = val_list.shift();
        if (leftVal != null) {
            node.left = new TreeNode(leftVal);
            nodeQueue.push(node.left);
        }
        // 构建：右孩子节点
        if (val_list.length === 0) {
            break;
        }
        var rightVal = val_list.shift();
        if (rightVal != null) {
            node.right = new TreeNode(rightVal);
            nodeQueue.push(node.right);
        }
    }
    return root;
}

（四）边的数组与图（邻接表）

//建造邻接表的图
//输入：numCourses = 2, prerequisites = [[1,0]]
//输出：[0,1]
//解释：总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为 [0,1] 。
var buildGraph = function(numCourses, prerequisites) {
    var graph = new Array(numCourses).fill(0)
    for (let i = 0; i < numCourses; i++) {
        graph[i] = []
    }
    for (let j = 0; j < prerequisites.length; j++) {
        let edge = prerequisites[j]
        let to = edge[0],
            from = edge[1]
        graph[from].push(to)
    }
    return graph
}

（其他）

字符与对应ASCII码var str = “A”;

小写：a->97
大写：A->65
将字母转为ascii

var str1 = 'a';
str1.charCodeAt();  // 97

将ascii码转为对应字母

var num = 97;
String.fromCharCode(num);  // 'a'

二维数组按第几个数字排序;

var arr1 = [[4,5,7],[11,3,6,100,77],[12,9,12,10],[3,1,2,99,22]];
function ascend(x,y){
    return x[3] - y[3];  //按照数组的第4个值升序排列
}
function descend(x,y){
    return y[0] - x[0];  //按照数组的第1个值降序排列
}
console.log(arr1.sort(ascend));
console.log(arr1.sort(descend));

sort()排序;

const students = [
    { name: "Devlin",   grade: 15 },
    { name: "Alex", grade: 15 },
    { name: "Eagle",  grade: 13 },
    { name: "Sam",    grade: 14 },
  ];

学生成绩升序排序

students.sort((firstItem, secondItem) => firstItem.grade - secondItem.grade);
console.log(students)
// 按成绩升序排序，相同成绩的保持原来的相对位置
/* [
    { name: 'Eagle', grade: 13 },
    { name: 'Sam', grade: 14 },
    { name: 'Devlin', grade: 15 },
    { name: 'Alex', grade: 15 }
] */

按学生成绩降序排序，相同成绩的按名字字典序排序

students.sort((a, b) => (b.grade - a.grade) || a.name.localeCompare(b.name));

按学生成绩降序排序，相同成绩的按学号升序排序

students.sort((a, b) => (b.grade - a.grade) || (a.id - b.id));

将数组中所有0前置，其余数升序排序

const arr = [1,0,-1,-9,0,4,6];
arr.sort((a,b)=> {
    if (a===0 && b !== 0) {
        // 返回负数，a排在b前面
        return -1;
    } else if (a !==0 && b===0) {
        // 返回正数，b排在a前面
        return 1;
    } else {
        return a-b;
    }
});
console.log(arr);
//[ 0, 0, -9, -1, 1, 4, 6 ]