一一一、算法与数据结构

链表

链表的创建以及增删改查操作

function LinkedList() {
var Node = function (element) {
this.element = element;
this.next = null;
};
var length = 0;
var head = null;
this.append = function (element) {
var node = new Node(element), current;
if (head === null) {
head = node
} else {
current = head
while (current.next) {
current = current.next
}
current.next = node
}
length++
};
this.insert = function (position, element) {
if (position >= 0 && position < length) {
var node = new Node(element), current = head, prev, index = 0
if (position === 0) {
node.next = current
head = node
} else {
while (index++ < position) {
prev = current
current = current.next
}
node.next = current
prev.next = node
}
length++
return node
} else {
return false
}
};
this.removeAt = function (position) {
if (position > -1 && position < length) {
var current = head, previous, index = 0
if (position === 0) {
head = current.next
} else {
while (index++ < position) {
previous = current
current = current.next
}
previous.next = current.next
length--
return current.element
}
} else {
return null
}
};
this.remove = function (element) {
var index = this.indexOf(element)
return this.removeAt(index)
};
this.indexOf = function (element) {
var current = head, index = 0
while (current) {
if (element === current.element) {
return index
}
index++
current = current.next
}
return -1
};
this.isEmpty = function () {
return length === 0
};
this.size = function () {
return length
};
this.toString = function () {
var current = head, string = ''
while (current) {
string += current.element
current = current.next
}
return string
};
this.getHead = function () {
return head
}
this.print = function () {
return this.toString()
};
}

/*======定义结构======*/
let node = function(element) {
this.element = element
this.next = null
}
let linkedList = function() {
this.head = new node('head')
this.find = find
this.insert = insert
this.update = update
this.remove = remove
this.reverse = reverse
}
/*======查找======*/
let find = function(item) {
let currNode = this.head
while (currNode.element !== item) {
currNode = currNode.next
}
return currNode
}
/*======插入======*/
/**
*newElement:一个新节点，item:链表的目标节点
*1.查找找到目标节点，将新节点的next指向目标节点的下一个节点
*2.将目标节点的next指向这个新节点
*/
let insert = function(newElement, item) {
let newNode = new node(newElement)
let currNode = this.find(item)
newNode.next = currNode.next
currNode.next = newNode
}
/*======修改======*/
/**
*查找到目标节点，将其element修改
*/
let update = function(item, newItem) {
let currNode = this.find(item)
currNode.element = newItem
}
/*======删除======*/
/**
*找到匹配节点的前一个节点，将其next指向当前节点的下一个节点，即删除当前节点
*/
let remove = function(item) {
let currNode = this.head
while (currNode.next !== null && currNode.next.element !== item) {
currNode = currNode.next
}
if (currNode.next !== null) {
currNode.next = currNode.next.next
}
}
/*======测试代码======*/
let list = new linkedList()
list.insert('first', 'head')
list.insert('second', 'first')
list.insert('third', 'second')
console.log(list)
list.find('first')
console.log(list.find('first'))
list.update('third','three')
console.log(list)
list.remove('second')
console.log(list)

最后

以上就是寂寞野狼为你收集整理的一一一、算法与数据结构的全部内容，希望文章能够帮你解决一一一、算法与数据结构所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。