㈠ 链表如何使用方法书上的程序看不懂。
简单来说链表就是由一种特殊结构数据节点串联起来线性数据序列，其中，每一个节点上的数据由两部分构成（通常定义成一个结构体）即存储数据的数据域和指向下一个节点的指针域构成。不要把它想得太复杂了。
每个节点就像带来尾巴的一个小球一样，（每个小球的前端有一个孔），尾巴就是节点的指针，通过将前一个小球的尾巴绑在后一个小球的孔上，将许多小球串起来就是一个链表。链表的插入删除就像从中间某处添加或去掉一个小球一样。
㈡ 建立一个数据为整型的单链表L，然后将该链表中数据域值最小的那个结点移到链表的最前端,
给你建立一个单链表，其中包括一些对链表的基本的操作，剩下的工作你自己做1.LstNodeusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace HelloWorld{/// <summary>/// List Node/// </summary>public class LstNode{private int _data;/// <summary>/// The data of LstNode/// </summary>public int Data{get { return _data; }set { _data = value; }}private LstNode _nextNode;/// <summary>/// The next node of LstNode/// </summary>public LstNode NextNode{get { return _nextNode; }set { _nextNode = value; }}public LstNode() { }public LstNode(int data) { _data = data; }}}</FONT></FONT></FONT>2.LinkedLstusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace HelloWorld{/// <summary>/// LinkedLst/// </summary>public class LinkedLst{private LstNode _head;/// <summary>/// Head of the list/// </summary>public LstNode Head{get { return _head; }set { _head = value; }}private int _count = 0;/// <summary>/// Counted the list length/// </summary>public int Count{get { return _count; }set { _count = value; }}/// <summary>/// Default Constructor/// </summary>public LinkedLst(){_head = null;}/// <summary>/// Init a list with head node/// </summary>/// <param name="head"></param>public LinkedLst(LstNode head){_head = head;if (_head == null) return;if (_count == 0){LstNode tempHead = _head;while (tempHead != null){_count++;tempHead = tempHead.NextNode;}}}/// <summary>/// Judge the list is empty or not/// </summary>/// <returns></returns>public bool IsEmpty(){return _head == null;}/// <summary>/// Clear the list/// </summary>public void Clear(){_head = null;}/// <summary>/// Add first(head) node /// </summary>/// <param name="value"></param>public void AddFirst(int value){LstNode node = new LstNode(value);if (IsEmpty()){_head = node;}else{LstNode tempNode = _head;_head = node;_head.NextNode = tempNode;}_count++;}/// <summary>/// Remove first(head) node/// </summary>/// <returns></returns>public int RemoveFirst(){if (IsEmpty()){return -1;}else{LstNode tempNode = _head;_head = _head.NextNode;_count--;return tempNode.Data;}}/// <summary>/// Add last node/// </summary>/// <param name="value"></param>/// <returns></returns>public void AddLast(int value){LstNode node = new LstNode(value);if (IsEmpty()){_head = node;}else{LstNode cursor = _head;while (cursor.NextNode != null){cursor = cursor.NextNode;}cursor.NextNode = node;}_count++;}/// <summary>/// Remove last node/// </summary>/// <returns>last node just removed</returns>public int RemoveLast(){if (IsEmpty()){return -1;}else{LstNode cursor = _head;LstNode secondNodeCountedFromLast = null;while (cursor.NextNode != null){secondNodeCountedFromLast = cursor;cursor = cursor.NextNode;}secondNodeCountedFromLast.NextNode = null;_count--;return cursor.Data;}}/// <summary>/// Remove lst[i] (0 <= i <= n)/// </summary>/// <param name="i"></param>/// <returns></returns>public int Remove(int i){if (IsEmpty()){return -1;}if (i < 0 || i > _count){return -1;}LstNode tempNode = null;if (i == 0){tempNode = _head;_head = _head.NextNode;_count--;return tempNode.Data;}LstNode cursor = _head;int tempI = 0;while (cursor != null){if (tempI++ == i - 1){tempNode = cursor.NextNode;cursor.NextNode = cursor.NextNode.NextNode;_count--;return tempNode.Data;}cursor = cursor.NextNode;}return -1;}public int this[int i]{get{if (i > _count || i < 0) return -1;int tempI = 0;LstNode tempNode = _head;while (tempNode != null){if (tempI++ == i){return tempNode.Data;}tempNode = tempNode.NextNode;}return -1;}set{this.AddLast(value);}}}} </FONT></FONT></FONT>用C#语言写的，希望能够帮助你，谢谢！
㈢ 链表的介绍
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。链表最明显的好处就是，常规数组排列关联项目的方式可能不同于这些数据项目在记忆体或磁盘上顺序，数据的存取往往要在不同的排列顺序中转换。链表允许插入和移除表上任意位置上的节点，但是不允许随机存取。链表有很多种不同的类型：单向链表，双向链表以及循环链表。链表可以在多种编程语言中实现。像Lisp和Scheme这样的语言的内建数据类型中就包含了链表的存取和操作。程序语言或面向对象语言，如C,C++和Java依靠易变工具来生成链表。
㈣ C语言队列，链表分别怎么用
队列
#include <stdio.h>
#include <stdlib.h>
#define N 11
typedef int data_t;
typedef struct sequeue {
data_t data[N];
int front, rear;
}sequeue_t;
//创建队列
sequeue_t *create_sequeue()
{
sequeue_t *sq = malloc(sizeof(sequeue_t));
sq->front = sq->rear = 0;
return sq;
}
//判断空
int empty_sequeue(sequeue_t *sq)
{
return sq->front == sq->rear;
}
//判断满(sq->rear + 1) % N == sq->front
int full_sequeue(sequeue_t *sq)
{
return (sq->rear + 1)%N == sq->front ;
}
int push_sequeue(sequeue_t *sq, data_t *data)
{
if(full_sequeue(sq))
return -1;
sq->rear = (sq->rear + 1)%N ;
sq->data[sq->rear] = *data;
return 0 ;
}
int pop_sequeue(sequeue_t *sq, data_t *data)
{
if(empty_sequeue(sq))
return -1;
sq->front = (sq->front + 1)%N ;
*data = sq->data[sq->front] ;
return 0;
}
//清空sq->front = sq->rear;
int clear_sequeue(sequeue_t *sq)
{
sq->front = sq->rear;
return 0;
}
//销毁
int detory_sequeue(sequeue_t *sq)
{
free(sq);
return 0;
}
int main(int argc, const char *argv[])
{
data_t data;
int i;
sequeue_t *sq = create_sequeue();
for(i = 0; i < 10; i++)
{
push_sequeue(sq, &i);
}
for(i = 0; i < 10; i++)
{
pop_sequeue(sq, &data);
printf("%d ", data);
}
putchar(10);
detory_sequeue(sq);
return 0;
}
链表
#include <stdio.h>
#include <stdlib.h>
typedef int data_t;
typedef struct linknode {
data_t data;
struct linknode *next;
}linknode_t, linklist_t;
//创建一个链表
//1. 在内存总开辟头结点的空间malloc
//2. 将头结点的next域置空NULL
//3. 返回创建并设置好的链表的首地址
linklist_t *create_linklist()
{
linklist_t *node;
node=(linklist_t *)malloc(sizeof(linklist_t));
node->next=NULL;
return node;
}
//判断当前链表是否为空
int empty_linklist(linklist_t *ll)
{
return ll->next == NULL;
}
//求链表中当前有效元素的个数
int length_linklist(linklist_t *ll)
{
int i;
for(i=0;ll->next != NULL;i++)
ll=ll->next;
return i;
}
//获得下标为index位置的元素，成功返回0，失败返回-1
//1. 判断index是否合法(部分判断)
//2. 在保证ll->next 不为空的清空下，将ll的首地址向后移动index次
//3. 判断ll->next 是否等于空，如果等于空，则返回-1，如果不为空，执行4.
//4. 当移动了index次之后，当前ll->next 的位置的节点就保存了我要获得的
//数据
//5. *data = ll->next->data;
//6. 返回0
int get_linklist(linklist_t *ll, int index, data_t *data)
{
int i;
if(index < 0)
return -1;
while( ll->next != NULL && index > 0)
{
ll=ll->next;
index--;
}
if( ll->next == NULL)
return -1;
*data = ll->next->data;
return 0;
}
//使用头插法插入一个元素
//1. 创建一个节点node
//2. 将要插入的数据保存到node
//3. 执行插入操作
//4. 返回0
int insert_linklist(linklist_t *ll, data_t *data)
{
linklist_t *node;
node=(linklist_t *)malloc(sizeof(linklist_t));
node->data=*data;
node->next=ll->next;
ll->next=node;
return 0;
}
//删除链表中的一个节点:删除头结点的后一个位置(头删法)
//首先可以判断当前链表是否为空，如果为空返回-1
//如果不为空则删除头结点的下一个位置的节点
//最后返回0
int delete_linklist(linklist_t *ll)
{
linklist_t *node;
if(ll->next == 0)
return -1;
node= ll->next;
ll->next =node->next;
free(node);
return 0;
}
//清空链表
//循环删除链表的一个节点，然后判断删除函数的返回值是否为0
//如果为0，继续删除，如果为-1则停止循环
int clear_linklist(linklist_t *ll)
{
while(delete_linklist(ll) == 0);
return 0;
}
//销毁链表
//1. 调用清空操作清空链表
//2. 删除头结点
//3. 返回0
int detory_linklist(linklist_t *ll)
{
free(ll);
return 0;
}
int main(void)
{
data_t data;
int i, length;
linklist_t *ll;
ll = create_linklist(); //创建一个链表
for(i = 0; i < 10; i++)
{
// i=i+65;
insert_linklist(ll, &i); //赋值 4 3 2 1 0
// i=i-65;
}
length = length_linklist(ll); //长度 输出
printf("链表有 %d 个数 \n",length);
for(i = 0; i < length; i++) //输出 链表内容
{
get_linklist(ll, i, &data);
printf("%d ", data);
}
putchar(10);
delete_linklist(ll); //删除头结点的后一个位置
length = length_linklist(ll); //长度 输出
printf("删除头结点的后一个位置的链表\n");
for(i = 0; i < length; i++) //输出 链表内容
{
get_linklist(ll, i, &data);
printf("%d ", data);
}
data = 692857680;
insert_linklist(ll, &data); //在头节点后添加 1 个数
length = length_linklist(ll);
printf("\n在头结点的后一个位置的添加我的QQ\n");
for(i = 0; i < length; i++)
{
get_linklist(ll, i, &data);
printf("%d ", data);
}
putchar(10);
clear_linklist(ll); //清空链表
length = length_linklist(ll);
printf("清空链表输出\n");
for(i = 0; i < length; i++)
{
get_linklist(ll, i, &data);
printf("%d ", data);
}
detory_linklist(ll);
return 0;
}
㈤ 前插法建立单链表问题
这是带头的链表吧！！
让newNode指向第一个结点 newNode->link=first->link;
然后再让头结点指向newNode，这样就一直前插了！
first应该是一个头结点吧！
㈥ 链表的定义
链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。链表中每一个元素称为“结点”，每个结点都应包括两个部分：一为用户需要用的实际数据，二为下一个结点的地址。因此，head指向第一个元素：第一个元素又指向第二个元素；……，直到最后一个元素，该元素不再指向其它元素，它称为“表尾”，它的地址部分放一个“NULL”（表示“空地址”），链表到此结束。
㈦ java里的链表指的是什么为什么需要链表
链表的确是一种数据结构．而数据结构就是一种存放数据的方式．
链表就是和铁链相似的．一个接着一个．一个扣着一个．
比如：
1，后面接着是2，然后是3，是连续的．1，2，3，就是这个链表的节点，就是数据存放的地方
再通俗点．
大学的校园生活：
班级是这样的．1年1班，1年2班，．．．．1年10班．
班级就是节点，而班级里的学生，就是数据．他们是连续存储的．但是内存分分配不是连续的．
有时间看下，＜数据结构＞书上写的很好．我就说到这吧．
㈧ 链表是什么！那个编程语言中有的，和数组有什么区别
一、主体不同
1、链表：是一种物理存储单元上非连续、非顺序的存储结构。
2、数组：是有序的元素序列。是用于储存多个相同类型数据的集合。
二、特点不同
1、链表：由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。
2、数组：是在程序设计中，为了处理方便， 把具有相同类型的若干元素按无序的形式组织起来的一种形式。
三、数据顺序不同
1、链表：数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
2、数组：数组中的各元素的存储是有先后顺序的，在内存中按照这个先后顺序连续存放在一起。
㈨ js链表怎么去输入啊
//Node表示要加入列表的项
varNode=function(element){
this.element=element;
this.next=null;
};
varlength=0;//存储列表项的数量
varhead=null;//head存储的是第一个节点的引用
//向链表尾部追加元素
this.append=function(element){
varnode=newNode(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>=0&&position<=length){
varnode=newNode(element),
current=head,
previous,
index=0;
if(position===0){
node.next=current;
head=node;
}else{
while(index<position){
previous=current;
previous.next=node;
index++;
}
node.next=current;
previous.next=node;
}
length++;
returntrue;
}else{
returnfalse;
}
};
//从链表中移除元素
this.removeAt=function(position){
if(position>-1&&position<length){
varcurrent=head,
previous,
index=0;
if(position===0){
head=current.next;
}else{
while(index<position){
previous=current;
current=current.next;
index++;
}
previous.next=current.next;
}
length--;
returncurrent.element;
}else{
returnnull;
}
};
//返回元素在链表中的位置
this.indexOf=function(element){
varcurrent=head,
index=-1;
while(current){
if(element===current.element){
returnindex;
}
index++;
current=current.next;
}
return-1;
};
//移除某个元素
this.remove=function(element){
varindex=this.indexOf(element);
returnthis.removeAt(index);
};
//判断链表是否为空
this.isEmpty=function(){
returnlength===0;
};
//返回链表的长度
this.size=function(){
returnlength;
};
//把LinkedList对象转换成一个字符串
this.toString=function(){
varcurrent=head,
string="";
while(current){
string=current.element;
current=current.next;
}
returnstring;
};
};
varlist=newLinkedList();
list.append(15);
list.append(10);
list.insert(1,11);
list.removeAt(2)
console.log(list.size());
㈩ 算法中的链表到底是什么，用处在哪里
链表由多个结点连接而成，一个结点分为数据域和指针域，数据域存储数据，指针域存储下一个结点的内存地址。链表结点的内存地址可以不连续，可以充分利用内存空间，代价是查找慢，必须从头结点开始查找。