本文目录一览：
求单链表的基本操作代码
#include stdio.h
#include windows.h
typedef struct node
{
int num;
struct node *next;
}lnode;
lnode *creat()
{
lnode *head,*p,*q;
int n;
head=NULL;
printf(“输入要创建的节点数\n”);
scanf(“%d”,n);
while(n)
{
p=(lnode *)malloc(sizeof(lnode));
printf(“输入数据\n”);
scanf(“%d”,p-num);
if (head==NULL)
{
head=q=p;
}
else
{
q-next=p;
q=p;
}
n–;
}
q-next=NULL;
return head;
}
lnode *insert(lnode *head)
{
lnode *p,*q,*s;
int n;
char ch;
q=p=head;
printf(“输入插入的位置\n”);
scanf(“%d”,n);
printf(“请选择是插入在前还是在后(F or B)\n”);
getchar();
ch=getchar();
if(ch==’F’||ch==’f’)
{
s=(lnode *)malloc(sizeof(lnode));
printf(“请输入数据\n”);
scanf(“%d”,s-num);
while(p–n)
{
q=p;
p=p-next;
}
if (q==p)
{
s-next=q;
return s;
}
else
{
q-next=s;
s-next=p;
return head;
}
}
else if (ch==’B’||ch==’b’)
{
s=(lnode *)malloc(sizeof(lnode));
printf(“请输入数据\n”);
scanf(“%d”,s-num);
while(pn–)
{
q=p;
p=p-next;
}
if (NULL==q-next)
{
q-next=s;
s-next=NULL;
return head;
}
else
{
q-next=s;
s-next=p;
return head;
}
}
else
{
printf(“输入错误\n”);
}
}
lnode *del(lnode *head)
{
lnode *p,*q;
int n;
int flag=0;
p=q=head;
printf(“请输入删除的数据\n”);
scanf(“%d”,n);
while(p)
{
if (p-num==n)
{
flag=1;
if (head==p)
{
head=head-next;
}
else if(NULL==p-next)
{
q-next=NULL;
}
else
{
q-next=p-next;
}
}
q=p;
p=p-next;
}
if (flag==0)
{
printf(“没有找到数据\n”);
system(“pause”);
}
else
{
printf(“删除成功\n”);
system(“pause”);
}
return head;
}
lnode *sort(lnode *head)
{
lnode *t,*f,*min,*p_min,*s;
char ch;
f=NULL;
printf(“请输入排序方式：升序(A/a),降序(D/d)\n”);
getchar();
ch=getchar();
if (ch==’A’||ch==’a’)
{
while(NULL!=head)
{
for (min=head,s=head;s-next!=NULL;s=s-next)
{
if (min-nums-next-num)
{
p_min=s;
min=s-next;
}
}
if (NULL==f)
{
f=min;
t=min;
}
else
{
t-next=min;
t=min;
}
if (min==head)
{
head=head-next;
}
else
{
p_min-next=min-next;
}
}
if (f!=NULL)
{
t-next=NULL;
}
printf(“排序完成\n”);
system(“pause”);
head=f;
return f;
}
else if (ch==’D’||ch==’d’)
{
while(NULL!=head)
{
for (min=head,s=head;s-next!=NULL;s=s-next)
{
if (min-nums-next-num)
{
p_min=s;
min=s-next;
}
}
if (NULL==f)
{
f=min;
t=min;
}
else
{
t-next=min;
t=min;
}
if (min==head)
{
head=head-next;
}
else
{
p_min-next=min-next;
}
}
if (f!=NULL)
{
t-next=NULL;
}
printf(“排序完成\n”);
system(“pause”);
head=f;
return f;
}
}
void dispaly(lnode *head)
{
lnode *p;
p=head;
printf(“\n”);
while(p!=NULL)
{
printf(“%d\t”,p-num);
p=p-next;
}
}
int getoption()
{
int n;
printf(“0 退出\n”);
printf(“1 创建链表\n”);
printf(“2 插入节点\n”);
printf(“3 删除节点\n”);
printf(“4 排序节点\n”);
printf(“5 显示链表\n”);
printf(“请选择操作\t”);
scanf(“%d”,n);
return n;
}
int main()
{
lnode *temp;
char ch;
int o;
do
{
system(“cls”);
o=getoption();
switch (o)
{
case 0:
exit(0);
break;
case 1 :
system(“cls”);
temp=creat();
break;
case 2:
system(“cls”);
temp=insert(temp);
break;
case 3:
system(“cls”);
temp=del(temp);
break;
case 4:
system(“cls”);
temp=sort(temp);
break;
case 5:
system(“cls”);
dispaly(temp);
system(“pause”);
break;
}
system(“cls”);
printf(“按0退出,任意键继续\t”);
ch=getchar();
if (ch==’0′)
{
exit(0);
}
} while (ch!=’0′);
}
JS中 数组与链表
常规数组： 数组元素内容是一种类型的元素，如const arr = [1,2,3,4]，在存储空间是连续内存的
JS数组： 数组元素内容不是同一种类型的元素，如const arr = [‘haha’, 1, {a:1}]，则在存储上是一段非连续空间。此时，JS 数组不再具有数组的特征，其底层其实是由链表来实现的
总结
链表的插入/删除效率较高，而访问效率较低；
数组的访问效率较高，而插入效率较低
js链表怎么去输入啊
//Node表示要加入列表的项
var Node=function(element){
this.element=element;
this.next=null;
};
var length=0;//存储列表项的数量
var head=null;//head存储的是第一个节点的引用
//向链表尾部追加元素
this.append=function(element){
var node=new Node(element),
current;
if(head===null){
head=node;
}else{
current=node;
while(current.next){
current=current.next;
}
current.next=node;
}
length++;
};
//在链表的任意位置插入元素
this.insert=function(position,element){
if(position=0position=length){
var node=new Node(element),
current=head,
previous,
index=0;
if(position===0){
node.next=current;
head=node;
}else{
while(indexposition){
previous=current;
previous.next=node;
index++;
}
node.next=current;
previous.next=node;
}
length++;
return true;
}else{
return false;
}
};
//从链表中移除元素
this.removeAt=function(position){
if(position-1 positionlength){
var current=head,
previous,
index=0;
if(position===0){
head=current.next;
}else{
while(indexposition){
previous=current;
current=current.next;
index++;
}
previous.next=current.next;
}
length–;
return current.element;
}else{
return null;
}
};
//返回元素在链表中的位置
this.indexOf=function(element){
var current=head,
index=-1;
while(current){
if(element===current.element){
return index;
}
index++;
current=current.next;
}
return -1;
};
//移除某个元素
this.remove=function(element){
var index=this.indexOf(element);
return this.removeAt(index);
};
//判断链表是否为空
this.isEmpty=function(){
return length===0;
};
//返回链表的长度
this.size=function(){
return length;
};
//把LinkedList对象转换成一个字符串
this.toString=function(){
var current=head,
string=””;
while(current){
string=current.element;
current=current.next;
}
return string;
};
};
var list=new LinkedList();
list.append(15);
list.append(10);
list.insert(1,11);
list.removeAt(2)
console.log(list.size());
js 删除链表中重复的节点
题目描述：
给定一个排序的链接列表，删除所有具有重复数字的节点，从原始列表中只留下不同的数字。
例如， 给定1- 2- 3- 3- 4- 4- 5，返回1- 2- 5。
给定1- 1- 1- 2- 3，返回2- 3。
JavaScript 版数据结构与算法（三）链表
可以看出JavaScript中的链表是通过不断 new 出来节点，并在节点的next属性上继续 new 创建出来的
结构大概长这样：
参考资料：
我该怎么在js里获取后台查询到的list
1、首先创建如下空链表，添加数据到链表中。
2、输出显示链表中的内容。
3、调用front获取list容器中的头部信息。
4、输出如下所示的数据，是list容器中的第一个信息。
5、调用back获取list容器中的尾部信息。
6、输出如下所示的数据，是list容器中的最后一个信息。
7、如果想要查找list容器中的某个元素，通过调用函数find实现，传入容器的起始位置、结束位置和需要查找的信息。
8、最后通过函数find返回的迭代器来判断是否查找到数据，并且获取数据内容。
【JS算法】 删除链表中某个节点
先来了解一个基础知识
b=a，但改变 b，并不会影响 a
y=x , 但改变y，会影响x，因为class有原型链
1=2=3，链表是由一组节点组成的集合。每个节点都使用一个对象的引用指向它的后继，指向另一个节点的引用叫做链
给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
输入：head = [1,2,6,3,4,5,6] val = 6
输出：[1,2,3,4,5]
原创文章，作者：小蓝，如若转载，请注明出处：https://www.506064.com/n/242991.html
微信扫一扫 
支付宝扫一扫 