㈠ 鏈表如何使用方法書上的程序看不懂。
簡單來說鏈表就是由一種特殊結構數據節點串聯起來線性數據序列，其中，每一個節點上的數據由兩部分構成（通常定義成一個結構體）即存儲數據的數據域和指向下一個節點的指針域構成。不要把它想得太復雜了。
每個節點就像帶來尾巴的一個小球一樣，（每個小球的前端有一個孔），尾巴就是節點的指針，通過將前一個小球的尾巴綁在後一個小球的孔上，將許多小球串起來就是一個鏈表。鏈表的插入刪除就像從中間某處添加或去掉一個小球一樣。
㈡ 建立一個數據為整型的單鏈表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());
㈩ 演算法中的鏈表到底是什麼，用處在哪裡
鏈表由多個結點連接而成，一個結點分為數據域和指針域，數據域存儲數據，指針域存儲下一個結點的內存地址。鏈表結點的內存地址可以不連續，可以充分利用內存空間，代價是查找慢，必須從頭結點開始查找。