单双链表（动态、静态、LIST)

前言

• 链表：用一组任意的存储单元存储线性表的数据元素（存储单元可以连续也可以不连续）。
• 链表操作：初始化、添加、遍历、插入、删除、查找、排序、释放等。
• 单向链表和双向链表

链表

单向链表中每个节点只包含一个指向下一个节点的指针，而双向链表中每个节点包含两个指针，一个指向前一个节点，一个指向后一个节点。

链表的优点在于可以动态添加或删除节点，不需要预先分配固定大小的存储空间。但是，由于链表不支持随机访问，需要通过遍历整个链表才能找到特定的节点，因此在某些场合下可能会影响性能。此外，在使用链表时需要注意链表的头节点，尾节点和指针的处理，避免出现死循环或内存泄漏等问题。

1.静态单向链表

静态链表使用预先分配的一段连续空间储存链表。

用连续空间实现链表，在逻辑上是成立的，具体有两种做法：

• 定义链表结构体数组，和动态链表的结构差不多；
• 使用一维数组，直接在数组上进行链表操作。

const int maxn=1e5+10;//数组大小=链表大小
int data[maxn],nxt[maxn];
int head,tail,cnt;
void insert_back(int x)//最前面插入x 
{
	data[++cnt]=x;
	nxt[tail]=cnt;
	tail=cnt;
    //nxt[tail]=head;循环链表
 } 
void insert_front(int x)//最后面插入x 
{
	data[++cnt]=x;
	nxt[cnt]=head;
	head=cnt;
     //nxt[tail]=head;循环链表
} 
void insert(int now,int x)//now后面插入x 
{
	data[++cnt]=x;
	nxt[cnt]=nxt[now];
	nxt[now]=cnt;
}
void del(int now) 
{
	nxt[now]=nxt[nxt[now]];
}
void 遍历()
{
	for(int i=head;i!=0;i=nxt[i])
	{
		操作data[i]; 
	}
 } 

给出使用一维数组实现单向静态链表实现代码约瑟夫环问题

//网代 
#include<bits/stdc++.h>
int nodes[150];
int main(){   
    int n, m;    
    scanf("%d%d", &n, &m); 
    for(int i=1;i<=n-1;i++)  nodes[i]=i+1; //nodes[i]的值就是下一个结点        
    nodes[n] = 1;                          //循环链表：尾指向头
    int now = 1, prev = 1;                 //从第1个开始
    while((n--) >1){
        for(int i = 1; i < m; i++){   //数到m，停下
            prev = now;   now = nodes[now];    //下一个
        }
        printf("%d ", now);           //带空格
        nodes[prev] = nodes[now];     //跳过结点now，即删除now
        now = nodes[prev];            //新的now
    }    
    printf("%d", now);                //打印最后一个，不带空格
    return 0;
}

//F老师的代码也可以参考
#include<bits/stdc++.h>
using namespace std;
struct node{
	int data;
	node *nxt;
};
node *head;
int main()
{
	int n,m;
	while(cin>>n>>m)
	{
		if(n==0&&m==0) break;
		head=new node();
		node *now;
		now=head;
		for(int i=1;i<n;i++)
		{
			now->data=i;
			now->nxt=new node();
			now=now->nxt;
		}
		now->data=n;
		now->nxt=head;
		node *p,*q;
		p=head;
		q=now;
		while(p->nxt!=p)
		{
			for(int i=1;i!=m;p=p->nxt,i++)	q=p;
			q->nxt=p->nxt;
			delete p;
			p=q->nxt;
		}
		
		cout<<p->data<<endl; 
	}
}

2.静态双向链表

const int maxn=1e5+10;
struct node
{
	int data;
	int nxt,pre;
}a[maxn]; 
int cnt=0;
void insert(int now,int x) 
{
	a[a[now].nxt].pre=cnt;
	a[cnt].nxt=a[now].nxt;
	a[now].nxt=cnt;
	a[cnt].pre=now;	 
}
void del(int now)
{
	a[a[now].pre].nxt=a[now].nxt;
	a[a[now].nxt].pre=a[now].pre;
}

3.动态链表

动态单项链表

• 临时分配链表结点、使用完毕后释放链表结点。
• 优点：能及时释放空间，不使用多余内存。
• 缺点：容易出错。

struct linkedlist{
	int data;
	linkedlist *nxt;
};
linkedlist *head,*tail;//创建两个结点指针变量
head=new linkedlist();//新建一个结点
head->data=10;//数据赋值
delete head;//删除结点
tail=head;//给节点整体赋值

动态单链表实现代码约瑟夫环问题

#include <bits/stdc++.h>
struct node{                            //定义链表结点
    int data;                           //结点的值
    node *next;                         //单向链表，只有一个next指针
};
int main(){
    int n,m;   scanf("%d %d",&n,&m);
    node *head,*p,*now,*prev;           //定义变量
    head = new node; head->data = 1; head->next=NULL; //分配第一个结点，数据置为1        
    now = head;                         //当前指针是头
    for(int i=2;i<=n;i++){
        p = new node;  p->data = i; p->next = NULL;  //p是新结点
        now->next = p;                  //把申请的新结点连到前面的链表上
        now = p;                        //尾指针后移一个
    }    
    now->next = head;                   //尾指针指向头：循环链表建立完成
//以上是建立链表，下面是本题的逻辑和流程。后面4种代码，逻辑流程完全一致。
    now = head, prev = head;            //从第1个开始数
    while((n--) >1 ){ 
        for(int i=1;i<m;i++){           //数到m，停下
            prev = now;                 //记录上一个位置，用于下面跳过第m个结点
            now = now->next; 
        }
        printf("%d ", now->data);       //输出第m结点，带空格
        prev->next = now->next;         //跳过这个结点
        delete now;                     //释放结点
        now = prev->next;               //新的一轮        
    }
    printf("%d", now->data);            //打印最后一个，后面不带空格
    delete now;                         //释放最后一个结点
    return 0;
}

4.STL list

list是双向链表，由标准模板库（Standard Template Library,STL）管理，通过指针访问节点数据，高效率的插入和删除。

list<T> myList;  // 创建一个名为myList的空列表，其中T是列表中元素的类型
cout<<mylist1.size();//mylist中元素个数
cout<<mylist.max_size();//mylist最多可容纳元素个数"
cout<<mylist.empty();//mylist2是否为空
int x = mylist.front();//访问第一个元素
int y = mylist.back();//访问最后一个元素
mylist.push_back(8);// 在list尾部插入一个元素8
mylist.push_front(8);// 在list尾部插入一个元素8
mylist.pop_back();// 删除mylist尾部一个元素
mylist.pop_front();// 删除mylist头部一个元素
mylist.clear();// 清除mylist中所有元素
mylist.remove(2);// 移除列表中所有值为2的元素
myList.reverse();// 列表中所有值反转逆序存储
myList.unique();//删除连续的重复元素 去重
myList.sort();//默认第一关键字升序排序

给出list实现约瑟夫问题的代码：

 
#include <bits/stdc++.h>
using namespace std;
int main(){
    int n, m;    cin>>n>>m;
    list<int>node;
    for(int i=1;i<=n;i++) node.push_back(i);   //建立链表             
    list<int>::iterator it = node.begin();
    while(node.size()>1){                      //list的大小由STL自己管理
        for(int i=1;i<m;i++){                  //数到m
             it++;
             if(it == node.end()) it = node.begin();  //循环：到末尾了再回头                                                              
        }
        cout << *it <<" ";
        list<int>::iterator next = ++it;
        if(next==node.end())  next=node.begin();  //循环链表
        node.erase(--it);                         //删除这个结点，node.size()自动减1
        it = next;
    }
    cout << *it;
    return 0;
 }