反转链表
输入:{1,2,3}
返回值:{3,2,1}
function ReverseList(pHead)
{
let nex = null, cur=pHead, pre = null;
while(cur) {
nex = cur.next;
cur.next = pre;
pre = cur;
cur = nex;
}
return pre
}
排序数组
//1.大顶堆
var bigHeap = (arr) => {
//1.构建大顶堆
for(let i = parseInt(arr.length/2-1); i>=0;i--){
adjustHeap(arr,i,arr.length)// //从第一个非叶子结点从下至上,从右至左调整结构
}
// 上述逻辑,建堆结束下面,开始排序逻辑
for(let j=arr.length-1;j>0;j--) {
// 元素交换,作用是去掉大顶堆
// 把大顶堆的根元素,放到数组的最后;换句话说,就是每一次的堆调整之后,都会有一个元素到达自己的最终位置
swap(arr, 0, j);//将堆顶元素与末尾元素进行交换.毫无疑问,最后一个元素无需再考虑排序问题了
adjustHeap(arr, 0, j)
}
return arr
}
var adjustHeap = (arr, i, len) => {
// 先把当前元素取出来,因为当前元素可能要一直移动
let tmp = arr[i];
for(let k=2*i+1; k<len; k=2*k+1) { //2*i+1为左子树i的左子树(因为i是从0开始的),2*k+1为k的左子树
if(k+1<len && arr[k] < arr[k+1]) {//如果左子结点小于右子结点,k指向右子结点
k++;
}
if(arr[k] > tmp) {//如果子节点大于父节点,将子节点值赋给父节点(不用进行交换)
arr[i] = arr[k];
i=k;
} else{
break;
}
}
arr[i] = tmp;//将temp值放到最终的位置
}
var swap = (arr, a, b) => {
let tmp = arr[a];
arr[a] = arr[b];
arr[b] = tmp;
}
2.快排序
function quickSort(arr) {
if (arr.length <= 1) return arr
let pivotIndex = Math.floor(arr.length / 2)
const pivot = arr[pivotIndex]
const left = [], right = []
for (let i = 0; i < arr.length; i++) {
if (i === pivotIndex) continue
if (arr[i] <= pivot) {
left.push(arr[i])
} else {
right.push(arr[i])
}
}
return quickSort(left).concat(pivot).concat(quickSort(right))
}
数组去重
//注意{} != {} NaN != NaN
Array.prototype.uniq = function () {
//return [...new Set(this)]
let ans = [],flag = true;
for(let i=0;i<this.length;i++){
if(ans.indexOf(this[i]) === -1) {
if(this[i] != this[i] && (typeof this[i] === 'number')) { //NaN
if(flag) {
ans.push(this[i]);
flag = false;
}
} else{
ans.push(this[i]);
}
}
}
return ans
}
时间格式化
输入:formatDate(new Date(1409894060000), ‘yyyy-MM-dd HH:mm:ss 星期w’)
输出:2014-09-05 13:14:20 星期五
function formatDate(time, mode) {
let obj={};
obj.yyyy = time.getFullYear();
obj.yy = time.getFullYear().slice(-2);
obj.MM = ('0'+(time.getMonth() + 1)).slice(-2);
obj.M = time.getMonth() + 1;
obj.dd = ('0'+time.getDate()).slice(-2);
obj.dd = time.getDate();
obj.HH = ('0'+time.getHours()).slice(-2);
obj.H = time.getHours();
obj.hh = ('0' + time.getHours()%12).slice(-2);
obj.h = time.getHours()%12;
obj.mm = ('0' + time.getMinutes()).slice(-2);
obj.m = time.getMinutes();
obj.ss = ('0' + time.getSeconds()).slice(-2);
obj.s = time.getSeconds();
obj.w = time.getSeconds();
let day = ['日', '一', '二', '三', '四', '五', '六'][date.getDay()];//星期0-6,0-日
return mode.replace(/[A-Za-z]+/g, function(str) {
return obj[str];
})
}
将字符串转为驼峰形式
‘font-size’---->fontSize
function cssStyle2DomStyle(sName) {
let arr = sName.split('')
if(arr[0]=='-') arr.splice(0,1)
for(let i in arr){
if(arr[i] == '-'){
arr.splice(i,1)
arr[i] = arr[i].toUpperCase()
}
}
let str = arr.join('')
return str
}
函数柯里化
柯里化是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数,并且返回接受余下的参数且返回结果的新函数的技术。
function curryIt(fn) {
var length = fn.length,
args = [];
var result = function (arg){
args.push(arg);
length --;
if(length <= 0 ){
return fn.apply(this, args);
} else {
return result;
}
}
return result;
}