STL之链表

最新推荐文章于 2024-09-24 17:00:43 发布

皮科克

最新推荐文章于 2024-09-24 17:00:43 发布

阅读量5.5k

点赞数

分类专栏： STL

STL 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

链表，通过指针来实现。

链表是一种数据结构，而list只是STL对于链表的一种实现，一万个人有可能写出一万种不同的链表来。

文字内容转自很长很详细的链表所有操作

图片理解转自这篇写的栈队列都很好理解

链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。链表中每一个元素称为“结点”，每个结点都应包括两个部分：一为用户需要用的实际数据，二为下一个结点的地址。因此，head指向第一个元素：第一个元素又指向第二个元素；……，直到最后一个元素，该元素不再指向其它元素，它称为“表尾”，它的地址部分放一个“NULL”（表示“空地址”），链表到此结束。

链表的各类操作包括：学习单向链表的创建、删除、插入（无序、有序）、输出、排序（选择、插入、冒泡）、反序等等。

（排序反序没写到这篇里XD）

创建n个节点的链表的函数为：

#include "cstdlib"  
#include "cstdio"  
#define NULL 0  
#define LEN sizeof(struct student)  
struct student  
{  
    int num;              //学号   
    float score;          //分数，其他信息可以继续在下面增加字段  
    struct student *next;       //指向下一节点的指针  
};  
int n;  //节点总数   
/* 
========================== 
功能：创建n个节点的链表 
返回：指向链表表头的指针 
========================== 
*/  
struct student *Create()  
{  
    struct student *head;       //头节点  
    struct student *p1 = NULL;  //p1保存创建的新节点的地址  
    struct student *p2 = NULL;  //p2保存原链表最后一个节点的地址  
  
    n = 0;          //创建前链表的节点总数为0：空链表  
    p1 = (struct student *) malloc (LEN);   //开辟一个新节点  
    p2 = p1;            //如果节点开辟成功，则p2先把它的指针保存下来以备后用  
  
    if(p1==NULL)        //节点开辟不成功  
    {  
        printf ("\nCann't create it, try it again in a moment!\n");  
        return NULL;  
    }  
    else                //节点开辟成功  
    {  
        head = NULL;        //开始head指向NULL  
        printf ("Please input %d node -- num,score: ", n + 1);  
        scanf ("%d %f", &(p1->num), &(p1->score));    //录入数据  
    }  
    while(p1->num != 0)      //只要学号不为0，就继续录入下一个节点  
    {  
        n += 1;         //节点总数增加1个  
        if(n == 1)      //如果节点总数是1，则head指向刚创建的节点p1  
        {  
            head = p1;  
            p2->next = NULL;  //此时的p2就是p1,也就是p1->next指向NULL。  
        }  
        else  
        {  
            p2->next = p1;   //指向上次下面刚刚开辟的新节点  
        }  
  
        p2 = p1;            //把p1的地址给p2保留，然后p1产生新的节点  
  
        p1 = (struct student *) malloc (LEN);  
        printf ("Please input %d node -- num,score: ", n + 1);  
        scanf ("%d %f", &(p1->num), &(p1->score));  
    }  
    p2->next = NULL;     //此句就是根据单向链表的最后一个节点要指向NULL  
  
    free(p1);           //p1->num为0的时候跳出了while循环，并且释放p1  
    p1 = NULL;          //特别不要忘记把释放的变量清空置为NULL,否则就变成"野指针"，即地址不确定的指针  
    return head;        //返回创建链表的头指针   
}

输出链表中节点的函数为：

/* 
=========================== 
 功能：输出节点 
 返回： void 
=========================== 
*/  
void Print(struct student *head)  
{  
    struct student *p;  
    printf ("\nNow , These %d records are:\n", n);  
    p = head;  
    if(head != NULL)        //只要不是空链表，就输出链表中所有节点  
    {  
        printf("head is %o\n", head);    //输出头指针指向的地址  
        do  
        {  
            /* 
            输出相应的值：当前节点地址、各字段值、当前节点的下一节点地址。 
            这样输出便于读者形象看到一个单向链表在计算机中的存储结构，和我们 
            设计的图示是一模一样的。 
            */  
            printf ("%o   %d   %5.1f   %o\n", p, p->num, p->score, p->next);  
            p = p->next;     //移到下一个节点  
        }  
        while (p != NULL);  
    }  
}

删除一个数据：

删除第一个节点，操作方法如下：
      1、你要明白head就是第1个节点，head->next就是第2个节点；
       2、删除后head指向第2个节点，就是让head=head->next,OK这样就行了。
       ---->[1]---->[2]---->[3]...---->[n]---->[NULL]（原链表）
       head   1->next 2->next 3->next   n->next

---->[1]---->[3]...---->[n]---->[NULL]（删除后链表）
head 1->next 3->next n->next

删除中间某个节点，这里删除第二个，操作方法如下：

1、你要明白head就是第1个节点，1->next就是第2个节点，2->next就是第3个节点；
2、删除后2，1指向第3个节点，就是让1->next=2->next。

删除指定学号的节点的函数为：

/* 
========================== 
 功能：删除指定节点 
  (此例中是删除指定学号的节点) 
 返回：指向链表表头的指针 
========================== 
*/  
struct student *Del (struct student *head, int num)  
{  
    struct student *p1;     //p1保存当前需要检查的节点的地址  
    struct student *p2;     //p2保存当前检查过的节点的地址  
    if (head == NULL)       //是空链表（结合图3理解）  
    {  
        printf ("\nList is null!\n");  
        return head;  
    }  
  
    //定位要删除的节点  
    p1 = head;  
    while (p1->num != num && p1->next != NULL)    //p1指向的节点不是所要查找的，并且它不是最后一个节点，就继续往下找  
    {  
        p2 = p1;            //保存当前节点的地址  
        p1 = p1->next;       //后移一个节点  
    }  
  
    if(p1->num==num)     //找到了。（结合图4、5理解）  
    {  
        if (p1 == head)     //如果要删除的节点是第一个节点  
        {  
            head = p1->next; //头指针指向第一个节点的后一个节点，也就是第二个节点。这样第一个节点就不在链表中，即删除  
        }  
        else            //如果是其它节点，则让原来指向当前节点的指针，指向它的下一个节点，完成删除  
        {  
            p2->next = p1->next;  
        }  
  
        free (p1);      //释放当前节点  
        p1 = NULL;  
        printf ("\ndelete %ld success!\n", num);  
        n -= 1;         //节点总数减1个  
    }  
    else                //没有找到  
    {  
        printf ("\n%ld not been found!\n", num);  
    }  
  
    return head;  
}

插入一个数据：

单向链表的插入图示：
---->[NULL]（原链表）
head

---->[1]---->[NULL]（插入后的链表）
head 1->next

      图7 空链表插入一个节点
      结合原链表和插入后的链表，就很容易写出相应的代码。操作方法如下：
     1、你要明白空链表head指向NULL就是head=NULL；
     2、插入后head指向第1个节点，就是让head=1,1->next=NULL,OK这样就行了。

---->[1]---->[2]---->[3]...---->[n]---->[NULL]（原链表）
head 1->next 2->next 3->next n->next

---->[1]---->[2]---->[x]---->[3]...---->[n]---->[NULL]（插入后的链表）
head 1->next 2->next x->next 3->next n->next

     图8：有N个节点的链表，插入一个节点（这里图示插入第2个后面）
     结合原链表和插入后的链表，就很容易写出相应的代码。操作方法如下：
    1、你要明白原1->next就是节点2，2->next就是节点3；
    2、插入后x指向第3个节点,2指向x，就是让x->next=2->next,1->next=x。

插入指定节点的后面的函数为：

/* 
========================== 
 功能：插入指定节点的后面 
  (此例中是指定学号的节点) 
 返回：指向链表表头的指针 
========================== 
*/  
struct student *Insert (struct student *head, int num, struct student *node)  
{  
    struct student *p1;     //p1保存当前需要检查的节点的地址  
    if (head == NULL)       //（结合图示7理解）  
    {  
        head = node;  
        node->next = NULL;  
        n += 1;  
        return head;  
    }  
  
    p1 = head;  
    while(p1->num != num && p1->next != NULL)  //p1指向的节点不是所要查找的，并且它不是最后一个节点，继续往下找  
    {  
        p1 = p1->next;       //后移一个节点  
    }  
  
    if (p1->num==num)        //找到了（结合图示8理解）  
    {  
        node->next = p1->next;    //显然node的下一节点是原p1的next  
        p1->next = node;     //插入后，原p1的下一节点就是要插入的node  
        n += 1;         //节点总数增加1个  
    }  
    else  
    {  
        printf ("\n%ld not been found!\n", num);  
    }  
    return head;  
}

例题： hdu 1276 士兵报数

#include<iostream>
#include<list>
using namespace std;
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        int n;
        cin>>n;
        list<int> s;
        if(n==0) cout<<0<<endl;
        else
        {
            for(int i=1; i<=n; i++)
                s.push_back(i);//把每一个数输入到链表中去
            list<int>::iterator it,ip;//链表遍历迭代器
            int f=1;
            int flag=s.size();
            while(flag>3)
            {
                for(it=s.begin(); it!=s.end();)
                {
                    if(f==2)//如果报到2就清除
                    {
                        f=1;
                        ip=it;
                        it++;
                        s.erase(ip);   //抹除操作
                        flag--;
                    }
                    else
                    {
                        f++;
                        it++;
                    }
                }
                f=1;
                if(flag<=3) break;
                for(it=s.begin(); it!=s.end();)
                {
                    if(f==3)//报到3就清除
                    {
                        f=1;
                        ip=it;
                        it++;
                        s.erase(ip);
                        flag--;
                    }
                    else
                    {
                        f++;
                        it++;
                    }
                }
                f=1;
                if(flag<=3) break;
            }
            int w=0;
            for(it=s.begin(); it!=s.end(); it++)
            {
                cout<<(*it);              //注意输出格式
                w++;
                if(w<=flag-1) cout<<' ';
            }
            cout<<endl;
        }
    }
    return 0;
}