《3-链表》

链表

引言：

存储数组需要内存空间连续，当我们需要申请一个很大的数组时，系统不一定存在这么大的连续内存空间。
而链表则更加灵活，不需要内存是连续的，只要剩余内存空间大小够用即可

1.定义 ：
「链表 Linked List」是一种线性数据结构，数据元素(即结点)的逻辑顺序之间通过指针连接。

由于结点中记录了连接关系，因此链表的存储方式相比于数组更加灵活，系统不必保证内存地址的连续性
链表的「结点Node」包含两项数据:
一是结点「值Value」；一个结点包含数据域和指针域，数据域--存放数据，指针域--链接。
二是指向下一结点的「指针Pointer」(或称「引用Reference」)。

/*链表定义*/ 
/*创建链表：添加一个指向下一个节点的指针，这个指针保存的是下一个节点的地址，代表这个指针指向下一个节点。*/
class ListNode{
	int val;//节点值 
	ListNode next;//指向下一节点的指针（引用） 
	ListNode(int x){val=x;}//构造函数 
}

尾结点的指向?

一般将链表的最后一个结点称为「尾结点」，其指向的是「空」，即为null（Java中）
 

2.链表的初始化
①.初始化各个结点对象

②.构建引用指向关系
完成后，即可以从链表的首个结点(即头结点)出发，访问其余所有的结点

/*初始化链表*/ 
ListNode n0=new ListNode(1);
ListNode n1=new ListNode(3);
ListNode n2=new ListNode(2);
ListNode n3=new ListNode(5);
ListNode n4=new ListNode(4);
//构造引用指向
n0.next=n1;
n1.next=n2;
n2.next=n3;
n3.next=n4;

通常将头结点当作链表的代称，例如头结点head和链表head实际上是同义的
 

3.优点
在链表中，①插入与②删除结点的操作效率高
①比如，如果我们想在链表中间的两个结点A, B之间插入一个新结点P，只需要改变两个结点指针即可，

时间复杂度为0(1)，相比数组的插入操作高效很多

/*在链表的节点n0之后插入节点P*/ 
void insert(ListNode n0,ListNode P){
	ListNode n1=n0.next;
	P.next=n1;
	n0.next=P;
}

②在链表中删除节点也非常方便，只需改变一个节点的指针即可
如下图所示，尽管在删除操作完成后，节点P仍然指向n1，但实际上P已经不再属于此链表，因为遍历此链表时无法访问到P

/*删除链表的节点n0之后的首个节点*/ 
void remove(ListNode n0){
	if(n0.next==null) return;
	ListNode P=n0.next;
	ListNode n1=P.next;
	n0.next=n1;
}

4.缺点
①链表访问结点效率低:
数组可以在0(1)时间下访问任意元素，但链表无法直接访问任意结点
//这是因为计算机需要从头结点出发，一个一个地向后遍历到目标结点
例如，倘若想要访问链表索引为index
(即第index+ 1个)的结点，那么需要index次访问操作

/*访问链表中的索引为Index*/ 
ListNode access(ListNode head,int index){
	for(int i=0;i<index;i++)
		if(head==null) return null;
	return head;
}

②链表的内存占用多
链表以结点为单位，每个结点除了保存值外，还需额外保存指针(引用)
----这意味着同样数据量下，链表比数组需要占用更多内存空间

5.常用操作

①单、双向链表：增，删，改，查；

②遍历链表查找：遍历链表，查找链表内值为target的结点，输出结点在链表中的索引

/*在链表中查找值为 target的首个节点*/ 
int find(ListNode head,int target){
	int index=0;
	while(head!=null){
		if(head.val==target) return index;
		head=head.next;
		index++; 
	}
	return -1;
}

6.常见链表类型
①单向链表：

即上述介绍的普通链表
单向链表的结点有「值」和指向下一结点的「指针(引用)」两项数据
将首个结点称为头结点，尾结点指向null

②双向链表：

单向链表仅记录了一个方向的指针(引用)，在双向链表的结点定义中，同时有指向下一结点(后继结点)和上一结点(前驱结点)的「指针(引用)」

③环形链表：

如果我们令单向链表的尾结点指向头结点(即首尾相接)，则得到一个环形链表
在环形链表中，可以将任意结点看作是头结点

应用--解决约瑟夫问题

扩展：

例题--说明list的应用（C++）

题目链接：Problem - 1276

士兵队列训练问题

Problem Description

某部队进行新兵队列训练，将新兵从一开始按顺序依次编号，并排成一行横队，训练的规则如下：从头开始一至二报数，凡报到二的出列，剩下的向小序号方向靠拢，再从头开始进行一至三报数，凡报到三的出列，剩下的向小序号方向靠拢，继续从头开始进行一至二报数。。。，以后从头开始轮流进行一至二报数、一至三报数直到剩下的人数不超过三人为止。

Input

本题有多个测试数据组，第一行为组数N，接着为N行新兵人数，新兵人数不超过5000。

Output

共有N行，分别对应输入的新兵人数，每行输出剩下的新兵最初的编号，编号之间有一个空格。

Sample Input

2
20 
40

Sample Output

1 7 19 
1 19 37

Author

Cai Minglun

Source

杭电ACM集训队训练赛（VI）

/*hdu 1276“士兵队列训练问题”    C++*/
#include<bits/stdc++.h>
using namespace std;
int main(){
    int t,n;
    cin>>t;
    while(t--){
        cin>>n;
        int k=2;//第一次删喊 “2 ”的 
        list<int> mylist;//定义
        list<int>::iterator it;
        for(int i=1;i<=n;i++) mylist.push_back(i);//赋值，存每个士兵的编号（索引加 1） 
        while(mylist.size()>3){
            int num=1;//设置一个 num来判断当前报数是不是 2（3）的倍数
            //不自动后移
            for(it=mylist.begin();it!=mylist.end();)
                if(num++%k==0) it=mylist.erase(it);//删除喊 “k ”的士兵，it指到下一位的地址 
                else it++;// it指到下一位的地址
            k==2?k=3:k=2;// 1至 2报数，1至 3报数
        }
        for(it=mylist.begin();it!=mylist.end();it++){
            if(it!=mylist.begin()) cout<<" ";
            cout<<*it;
        }
        cout<<endl;
    }
    return 0;
}

----双向链表相对于单向链表更加灵活，即可以朝两个方向遍历链表，但也需要占用更多的内存空间

/*双向链表节点类*/ 
class ListNode{
	int val;//节点值 
	ListNode next;//指向后继节点的指针（引用） 
	ListNode prev;//指向前驱节点的指针（引用） 
	ListNode(int x){val=x;}//构造函数 
}

//笔记笔记