整数链表学习

整数链表： 仔细阅读相应的例子， 掌握链表的创建， 插入节点， 删除节点，
遍历和查询， 并用类进行封装
 

例1：
#include <stdio.h>
#include <stdlib.h>
struct Student//声明结构体类型struct Student
{
    int num;
    float score;
    struct Student * next;
};


int main()
{
    struct Student a,b,c,*head,*p;//定义3个结构体变量abc作为链表的结点
    a.num=10101;
    a.score=89.5;
    b.num=10103;
    b.score=90;
    c.num=10107;
    c.score=85;
    head=&a;//a结点的起始位置赋给头指针head
    a.next=&b;//b的起始地址赋给a结点的next成员
    b.next=&c;//将c结点的起始位置赋给b结点的next成员
    c.next=NULL;//c结点的next成员不存在放其他地址
    p=head;//使p指向a结点
    do
    {
        printf("%d %5.1f\n",p->num,p->score);
        p=p->next;//使p指向下一结点
    }
    while(p!=NULL);//输出完c结点后p的值为NULL，循环终止2
    return 0;
}


例2：
#include <iostream>
#include<cstring>
using namespace std;


typedef struct node
{
    string name;
    int age;
    struct node*next;
} student; //因为struct node很长，所以struct node的别名为student


//创建一个长度为n的链表
student* createlist(int n)
{

    student* head=new student;//生成头结点

    student* pre=head;  //pre为前一个结点
    for(int i=0; i<n; i++)
    {
        student*p=new student;//生成普通结点

        cout<<"请输入第"<<i+1<<"个数据"<<endl;//输入数据
        cin>>p->name>>p->age;
        //构建结点间的关系
        pre->next=p;//前一个结点的next存放后一个结点的地址
        pre=p;//后一个结点变成了前一个结点
        p->next=NULL;//后一个结点的next里为空
    }
    return head;//返回头结点
}



void printlist(student* head)//遍历链表
{
    student* p=head->next;//头结点只有next，没有data
    cout<<"遍历链表"<<endl;
    while(p!=NULL)
    {
        cout<<p->name<<p->age<<endl;
        p=p->next;
    }
}



void findelement(student *head,int i)//查找元素
{
    int j=1;
    student *p=head->next;
    while(j<i)
    {
        p=p->next;//链表一个一个向后走
        j++;
    }
    if(j==i)
    {
        cout<<"---查找的结点的数据为---"<<endl;
        cout<<p->name<<p->age<<endl;
    }
}


void inerNode(student*head,int i)//插入结点,两个参数：第一个是用head区分链表，第二个是在第i个结点后插入
{
    int j=1;
    student *p=head->next;//从头结点开始
    while(j<i)
    {
        p=p->next;
        j++;
    }

    //找到p之后，在p结点后插入q结点
    if(j==i)
    {

        student *q=new student;//1创建一个要插入的新的结点，结点是一个地址
        cout<<"请输入要在第"<<i<<"个结点后插入的数据"<<endl;
        string name;
        int age;
        cin>>name>>age;
        q->name=name;
        q->age=age;//赋值

        //p q s这两步的顺序不可以改变，否则s的地址找不到
        q->next=p->next;//q的next放s结点，在没插入q之前,p的next放的是s
        p->next=q;
    }


}



void deleteNode(student* head,int i)//删除结点
{
    //删除第i个结点  i--q

    int j=1;
    i=i-1;//1.找到第i-1个结点--p
    student *p=head->next;
    while(j<i)
    {
        p=p->next;
        j++;
    }
    if(j==i)
    {
        student *q =p->next;//q是p的下一个结点，通过p找q
        p->next=q->next;//q的前后两个结点建立联系
        cout<<"删除成功"<<"删除的数据为"<<q->name<<q->age<<endl;
        delete q;//删除多余的q
    }

}
int main()
{
    student*head1=createlist(5);//创建一个长度为5的链表
    printlist(head1);//打印
    findelement(head1,4);//查找
    inerNode(head1,3);//插入
    printlist(head1);//打印
    deleteNode(head1,3);//删除
    printlist(head1);//打印
    return 0;
}

例三：
#include <iostream>

using namespace std;

class Student
{
private:
    string id;
    string name;
    int age;
public:
    Student(){}
    Student(string id ,string name,int age):
    id(id),name(name),age(age){}
    void display()
    {
       cout<<id<<" "<<name<<" "<<age<<" "<<endl;
    }
};

class Node//结点类
{
public:
    Student data;
    Node* next;//指向下一个结点的指针
    Node()
    {
        next=nullptr;
    }
    Node(Student& s)
    {
        data=s;
        next=nullptr;
    }
    void display()
    {
        data.display();
    }
};

//class Link//链表类
//{
//public:
//    Node* head;//头结点，永远不会变
//    Link()
//    {
//        //在堆区建
//        head=new Node();//新建一个头结点
//        //head->next=nullptr;
//
//    }
//
//    void addNode(Node* s)//添加
//    {
//        Node* p=new Node(*s);//新增一个结点p
//        p->next=head->next;
//        head->next=p;
//    }
//
//    void deleteNode(string id)//删除，当id唯一时
//    {
//        Node* q=head;//伴随指针，永远指向p指针的上一个结点
//        Node* p=head->next;//p初始指向第一个数据结点
//        while(p!=nullptr)
//        {
//            if(p->id==id)
//            {
//                q->next=p->next;
//                delete p;
//                break;//id唯一
//                //当id不唯一时
//                //q指向a[i-1],p是一个无意义的值
//                //p=q->next;重新恢复，p指向啊[i+1]
//            }
//            else
//            {
//                p=p->next;
//                q=q->next;
//            }
//        }
//    }
//
//
//    void modifyNode(string id,int age)//改年龄
//    {
//
//        Node* p=head->next;
//        while(p!=nullptr)
//        {
//            if(p->id==id)
//            {
//                p->age=age;
//            }
//            break;//id唯一时
//            /*id不唯一时
//            p=p->next;
//            */
//        }
//    }
//
//    void traverse()//遍历输出
//    {
//        Node* p=head->next;
//        while(p!=nullptr)
//        {
//            p->display();
//            p=p->next;
//        }
//    }
//
//    ~Link()//回收内存空间
//    {
//        Node* p=head;
//        Node* q;//临时变量
//        while(p!=nullptr)
//        {
//            q=p->next;
//            delete p;//回收p指向的空间
//            p=q;//p指向下一个结点
//        }
//    }
//
//
//};
//

int main()
{
    
    Student s("1111111111","lihua",21);
    Node n(s);
    n.display();
    
    return 0;
}