静态链表常用操作(节点计数/查找/增加/删除)

1.封装计算链表节点个数的API

代码心得:

  1. cnt是count的缩写,用来计数。
  2. 节点,我们一般指的是链表中数据的地址(指针)。比如节点1就是第一个结构体的地址,节点2就是第2个结构体的地址,以此类推。
  3. 函数接收链表头以后,再修改head指向,看起来有点奇怪(实际上没什么问题,因为main函数中的head不会变),最好养成习惯,在函数中另外定义一个代表节点的结构体指针p保存head的值,让p去移动。

1、计算链表节点个数:

  1. 思路:
    f1. 封装计算链表节点个数的API: int getLinkNodeNum(struct Test *head); 形参head用来接收链表头
    	f1.1 while,控制循环的变量是链表头head,当head!=NULL 时,进入循环
        //内在逻辑:当结构体指针head不等于NULL时,说明没有访问到链表尾巴的后面
        	f1.1.1 修改代表节点个数的变量cnt: cnt++;  //注意一开始要将cnt初始化成0
            f1.1.2 修改代表节点的循环变量head,让head往后走: head = head->next;
    	f1.2 返回代表节点个数的变量cnt

  2. 代码:
    #include 
    struct Test
    {
        int idata;
        struct Test *next;
    };
    int getLinkNodeNum(struct Test *head);
    int main(int argc, char const *argv[])
    {
        int cnt = 0;
        struct Test t1 = {1,NULL};
        struct Test t2 = {2,NULL}; 
        struct Test t3 = {3,NULL};
        struct Test t4 = {4,NULL};
        t1.next = &t2;                 
        t2.next = &t3; 
        t3.next = &t4; 
        cnt = getLinkNodeNum(&t1);
        printf("node numbers: %d\n", cnt);
        return 0;
    }
    int getLinkNodeNum(struct Test *head) 
    {
        int cnt = 0;
        while(head != NULL){
            cnt++;
            head = head->next;
        }
        return cnt;
    }

2.封装链表查找的API

  1. 思路:
    f1. 封装链表查找的API: int searchLink(struct Test *head, int idata); 
    形参head用来接收链表头,形参idata是想要找的整型数据
    	f1.1 while,控制循环的变量是链表头head,当head!=NULL 时,进入循环
        //内在逻辑:当结构体指针head不等于NULL时,说明没有访问到链表尾巴的后面
        	f1.1.1 通过结构体指针间接访问成员变量idata,判断head->idata是否等于idata
            	f1.1.1.1 如果是,
                			那么,返回1
        	f1.1.2 修改代表节点的循环变量head,让head往后走: head = head->next;
    	f1.2 返回0
        //内在逻辑:如果顺利通过f1.1,说明没有提前退出循环,也就是没找到idata

  2. 代码:
    #include 
    struct Test
    {
        int idata;
        struct Test *next;
    };
    int searchLink(struct Test *head, int idata);
    int main(int argc, char const *argv[])
    {
        struct Test t1 = {1,NULL};
        struct Test t2 = {2,NULL}; 
        struct Test t3 = {3,NULL};
        struct Test t4 = {4,NULL};
        t1.next = &t2;                 
        t2.next = &t3; 
        t3.next = &t4; 
        if(searchLink(&t1, 5)){
            puts("找到了");
        }else{
            puts("没找到");
        }
        return 0;
    }
    int searchLink(struct Test *head, int idata)
    {
        while(head != NULL){
            if(head->idata == idata){
                return 1;
            }
            head = head->next;
        }
        return 0;
    }

3.封装链表中插入新节点的API

代码心得:

  1. 我们如何表示链表中的数据(结构体)是第几个节点呢?其实可以在结构体中定义一个代表当前节点位置的成员变量,不妨叫做node。
  2. 插入前,新插入的节点new的指向要设置成NULL,因为我们不知道这个链表数据的后面是什么,如果选择在链表末尾那个数据后面插入节点new的话,那么节点new就成为了链表的末尾,因此NULL是必须的。
  3. 如果有必要修改main函数中的链表头head的指向,也就是修改指针head的值,我们之前讲过,有两种思路,一是用指针函数返回一个结构体指针,二是传递&head后在函数中用结构体二级指针修改head的值。我们推荐用前一种,不容易出错。
  4. 初始化链表的时候,可以提前定义一个结构体指针变量head表示链表头,在链表创建完毕后令head=&t1
  5. 以下两种插入方法,只要是正常插入(不涉及链表头的改变),成功插入新节点new后,p->next立马就变成了new,因此成功插入后最好直接退出while循环,不要让p往后移动了,防止死循环(见f1.2、f1.3)。

知识点:插入新节点有两种方式,每种方式中修改节点指向时,需要注意赋值的顺序

  1. 节点后插入:以在节点3后方插入新节点New为例,必须要让原先节点3和节点4之间的连线最后断掉。静态链表常用操作(节点计数/查找/增加/删除)_第1张图片
    1. 找到节点3
    2. 让节点New先指向节点3原先的指向,也就是节点4
    3. 让节点3指向节点New,断开3与4的连接
    4. 依次修改new节点后面节点的节点位置标志node(必要的话)
  2. 节点前插入:要考虑插入的是否是第一个节点之前。①如果在第一个节点之前插入新节点,那么链表头会发生变化,体现在main函数中的head的指向发生变化。②如果不是在第一个节点之前插入,那么不需要修改链表头,以在节点4前方插入新节点New为例,这里要注意:不能等到节点p移到4的位置才插入,而是需要通过节点3找节点4,因为我们需要修改节点3的指向,所以这部分代码和在节点后插入类似。静态链表常用操作(节点计数/查找/增加/删除)_第2张图片

 

1、节点后插入的方式:

  1. 思路:
    f1. 封装在链表某节点后插入新节点的API: 
    int inserFromBehind(struct Test *head, int nodePosition, struct Test *new); 
    形参head用来接收链表头,形参nodePosition代表想要在第几个节点后插入,形参new代表新节点
    	f1.1 新定义一个代表节点的结构体指针变量p,用来保存链表头head
    	f1.2 while循环,控制循环的变量是链表头p,当p!=NULL 时,进入循环,找出位置插入新节点new
        //内在逻辑:当结构体指针head不等于NULL时,说明没有访问到链表尾巴的后面
        	f1.2.1 通过结构体指针间接访问成员变量node(node代表当前第几个节点),
            判断 p->node 是否等于nodePosition
            	f1.2.1.1 如果是,
                	f1.2.1.1.1 修改代表找到设定节点位置nodePosition的变量flag: flag = 1;
    				//内在逻辑:用flag=1代表找到了位置插入,flag=0代表没有找到位置插入,可以初始化成0
    				f1.2.1.1.2 让节点new先指向节点p原先的指向: new->next = p->next;
    				f1.2.1.1.3 让节点p指向节点new,断开节点p和它原先后面节点的连接
                   	f1.2.1.1.4 修改节点new中的成员node: new->node = nodePosition + 1;
    				//内在逻辑:找到可插入位置并插入后,把代表节点编号的node成员变量修改一下
    				f1.2.1.1.5 插入成功后,提前退出循环,不急着退出函数,一会来改后面节点的node
                f1.2.1.2 修改代表节点的循环变量p,让p往后走: p = p->next;
        f1.3 判断代表找到设定节点位置nodePosition的变量flag是否等于1
        //内在逻辑:插入成功后,在return 1之前,修改新插入节点后面节点的节点位置标志node,让它们加1。
        	f1.3.1 如果是,接下来让new节点后面的节点中的node成员变量自增1
            	f1.3.1.1 修改代表节点的变量p,让p往后走: p = p->next;
    			f1.3.1.2 修改代表节点的变量p,让p往后走: p = p->next;
    			//内在逻辑:两次往后走是因为想跳过新插入的节点
    			f1.3.1.3 while循环,控制循环的变量p,当p!=NULL 时,进入循环
                	f1.3.1.3.1 修改循环变量p中的node成员变量,自增1: p->node = p->node + 1;
    				f1.3.1.3.2 修改代表节点的循环变量p,让p往后走: p = p->next;
    			f1.3.1.4 修改完毕,返回1,结束函数。
    		f1.3.2 否则,代表插入失败(比如新节点插入的位置输入的过大)
            	那么,返回0

  2. 代码:
    #include 
    struct Test
    {
        int node;
        struct Test *next;
    };
    void printLink(struct Test *head);
    int inserFromBehind(struct Test *head, int nodePosition, struct Test *new);
    int main(int argc, char const *argv[])
    {
        struct Test t1 = {1,NULL};
        struct Test t2 = {2,NULL}; 
        struct Test t3 = {3,NULL};
        struct Test t4 = {4,NULL};
        t1.next = &t2;                 
        t2.next = &t3; 
        t3.next = &t4; 
        struct Test new = {0,NULL};					//新插入的节点new的指向要设置成NULL
        int nodePosition;
        puts("插入新节点以前");
        printLink(&t1);
        puts("请输入在哪个节点后插入新节点");
        scanf("%d", &nodePosition);
        inserFromBehind(&t1, nodePosition, &new);
        puts("插入新节点以后");
        printLink(&t1);
        return 0;
    }
    void printLink(struct Test *head) 
    {
        while(head != NULL){
            printf("%d ", head->node);
            head = head->next;
        }
        putchar('\n');
    }
    int inserFromBehind(struct Test *head, int nodePosition, struct Test *new)
    {
        struct Test *p = head;
        int flag = 0;
        while(p != NULL){
            if(p->node == nodePosition){
                flag = 1;
                new->next = p->next;
                p->next = new;
                new->node = nodePosition + 1;
                break;
            }
            p = p->next;
        }
        if(flag == 1){
            p = p->next;
            p = p->next;
            while(p != NULL){
                p->node = p->node + 1;
                p = p->next;
            }
            return 1;
        }else{
            return 0;
        }
    }

2、节点前插入的方式:

  1. 思路:
    f1. 封装在链表某节点前插入新节点的API: 
    struct Test* inserFromFront(struct Test *head, int nodePosition, struct Test *new); 
    形参head用来接收链表头,形参nodePosition代表想要在第几个节点前插入,形参new代表新节点,
    返回值是结构体指针,用来修改main函数的链表头head
    	f1.1 新定义一个代表节点的结构体指针变量p,用来保存链表头head
        f1.2 判断是否要在第一个节点前插入新节点,
        	f1.2.1 如果是,说明链表头需要改动
            	f1.2.1.1 让新节点指向旧链表头,让节点new成为新链表头: new->next = head;
    			f1.2.1.2 修改节点new的node为1: new->node = 1;
    			f1.2.1.3 while循环,控制循环的变量p,当p!=NULL 时,进入循环,把后面所有节点的node+1
                    f1.2.1.3.1 从节点p开始,也就是从旧链表头开始,修改node: p->node = p->node + 1;
    				f1.2.1.3.2 修改代表节点的循环变量p,让p往后走: p = p->next;
    			f1.2.1.4 返回new节点,提前结束函数: return new;
    	f1.3 while循环,控制循环的变量是链表头p,当p->next!=NULL 时,进入循环,找出位置插入新节点new
        //内在逻辑1:如果跳过了f1.2,那么说明不用修改链表头,接下来就正常插入
        //内在逻辑2:因为我们希望通过设定节点的上一个节点来找设定节点,不能等到p移到设定节点的位置才插入
        	f1.3.1 通过前一个节点访问后一个节点的node,判断 p->next->node 是否等于nodePosition
            	f1.3.1.1 如果是,
                	f1.3.1.1.1 修改代表找到设定节点位置nodePosition的变量flag: flag = 1;
    				//内在逻辑:用flag=1代表找到了位置插入,flag=0代表没有找到位置插入,flag初始化成0
    				f1.3.1.1.2 让节点new先指向节点p原先的指向: new->next = p->next;
    				f1.3.1.1.3 让节点p指向节点new,断开节点p和它原先后面节点的连接: p->next = new;
                   	f1.3.1.1.4 修改节点new的node: new->node = nodePosition;
    				//内在逻辑:找到可插入位置并插入后,把代表节点编号的node成员变量修改一下
    				f1.3.1.1.5 插入成功后,提前退出循环,不急着退出函数,一会来改后面节点的node
                f1.3.1.2 修改代表节点的循环变量p,让p往后走: p = p->next;
        f1.4 判断代表找到设定节点位置nodePosition的变量flag是否等于1
        //内在逻辑:插入成功后,在return head之前,修改新插入节点后面节点的node,让它们加1。
        	f1.4.1 如果是,接下来让new节点后面的节点中的node成员变量自增1
            	f1.4.1.1 修改代表节点的变量p,让p往后走: p = p->next;
    			f1.4.1.2 修改代表节点的变量p,让p往后走: p = p->next;
    			//内在逻辑:两次往后走是因为想跳过新插入的节点
    			f1.4.1.3 while循环,控制循环的变量p,当p!=NULL 时,进入循环
                	f1.4.1.3.1 修改循环变量p中的node成员变量,自增1: p->node = p->node + 1;
    				f1.4.1.3.2 修改代表节点的循环变量p,让p往后走: p = p->next;
    			f1.4.1.4 修改完毕,返回head,结束函数。
                //内在逻辑,不需要修改链表头时,直接返回原先的链表头即可
    		f1.4.2 否则,代表插入失败(比如新节点插入的位置输入的过大)
            	那么,返回head
               	//内在逻辑:即使插入失败,我们也不希望链表头发生改变

  2. 代码:
    #include 
    struct Test
    {
        int node;
        struct Test *next;
    };
    void printLink(struct Test *head);
    struct Test* inserFromFront(struct Test *head, int nodePosition, struct Test *new);
    int main(int argc, char const *argv[])
    {
        struct Test *head;
        struct Test t1 = {1,NULL};
        struct Test t2 = {2,NULL}; 
        struct Test t3 = {3,NULL};
        struct Test t4 = {4,NULL};
        t1.next = &t2;                 
        t2.next = &t3; 
        t3.next = &t4; 
        head = &t1;
        struct Test new = {0,NULL};
        int nodePosition;
        puts("插入新节点以前");
        printLink(head);
        puts("请输入在哪个节点前插入新节点");
        scanf("%d", &nodePosition);
        head = inserFromFront(head, nodePosition, &new); 
        puts("插入新节点以后");
        printLink(head);
        return 0;
    }
    void printLink(struct Test *head) 
    { 
        while(head != NULL){
            printf("%d ", head->node);
            head = head->next;
        }
        putchar('\n');
    }
    struct Test* inserFromFront(struct Test *head, int nodePosition, struct Test *new)
    {
        int flag = 0;
        struct Test *p = head;
        if(nodePosition == 1){
            new->next = head;
            new->node = 1;
            while(p != NULL){
                p->node = p->node + 1;
                p = p->next;    
            }
            return new;
        }
        while(p->next != NULL){
            if(p->next->node == nodePosition){
                flag = 1;
                new->next = p->next;
                p->next = new;
                new->node = nodePosition;
                break;
            }  
            p = p->next;
        }
        if(flag == 1){
            p = p->next;
            p = p->next;
            while(p != NULL){
                p->node = p->node + 1;
                p = p->next;
            }
            return head;
        }else{
            puts("插入失败");
            return head;
        }
    }

4.封装删除静态链表节点的API

代码心得:

  1. 我们现在所讲的删除链表节点的方法,不涉及到释放被删除节点的内存空间,因为目前我们学习到的链表的内存是静态分配的。我们将在第3节(链表动态创建)中去完善删除节点的代码。

知识点:

  1. 删除节点时,要考虑删除的是否是第一个节点。①如果删除第一个节点,那么链表头会发生变化,体现在main函数中的head的指向发生变化。②如果删除的不是第一个节点,那么不需要修改链表头,以删除节点4为例,这里要注意:不能等到节点p移到4的位置才进行删除,而是需要通过节点3找节点4,因为我们需要修改节点3的指向(绕过节点4,指向节点5)。静态链表常用操作(节点计数/查找/增加/删除)_第3张图片

 

1、删除链表节点的方式:

  1. 思路:
    f1. 封装删除静态链表某节点的API: struct Test* delNode(struct Test *head, int nodePosition);
    形参head用来接收链表头,形参nodePosition代表想要删除第几个,
    返回值是结构体指针,用来修改main函数的链表头head
    	f1.1 新定义一个代表节点的结构体指针变量p,用来保存链表头head
        f1.2 判断是否删除的是第1个节点
        	f1.2.1 如果是,说明链表头需要改动
            	f1.2.1.1 修改链表头的指向,让head指向节点2: head = head->next;
    			f1.2.1.2 将节点p移动到新链表头,接下来准备修改往后各个节点的node: p = head;
    			f1.2.1.3 while循环,控制循环的变量p,当p!=NULL 时,进入循环,把后面所有节点的node-1
                    f1.2.1.3.1 从节点p开始,也就是从新链表头开始,修改node: p->node = p->node - 1;
    				f1.2.1.3.2 修改代表节点的循环变量p,让p往后走: p = p->next;
    			f1.2.1.4 返回节点head,提前结束函数: return new;
    	f1.3 while循环,控制循环的变量是链表头p,当p->next!=NULL 时,进入循环,找出位置插入新节点new
        //内在逻辑1:如果跳过了f1.2,那么说明不用修改链表头,接下来就正常删除
        //内在逻辑2:因为我们希望通过设定节点的上一个节点来找设定节点,不能等到p移到设定节点的位置才删除
        	f1.3.1 通过前一个节点访问后一个节点的node,判断 p->next->node 是否等于nodePosition
            	f1.3.1.1 如果是,
                	f1.3.1.1.1 修改代表找到设定节点位置nodePosition的变量flag: flag = 1;
    				//内在逻辑:用flag=1代表找到了位置删除,flag=0代表没有找到位置删除,flag初始化成0
    				f1.3.1.1.2 让节点p指向设定删除节点的后一个节点,断开节点p和它原先后面节点的连接: 
    					p->next = p->next->next;
    				f1.3.1.1.3 删除成功后,提前退出循环,不急着退出函数,一会来改后面节点的node
                f1.3.1.2 修改代表节点的循环变量p,让p往后走: p = p->next;
        f1.4 判断代表找到设定节点位置nodePosition的变量flag是否等于1
        //内在逻辑:删除成功后,在return head之前,修改被删除节点后面节点的node,让它们减1。
        	f1.4.1 如果是,接下来让被删节点后面的节点中的node成员变量自减1
            	f1.4.1.1 修改代表节点的变量p,让p往后走: p = p->next;
    			//内在逻辑:比如说删除节点4之后,那么就从节点3跳到节点5,从原先的节点5位置开始修改node
    			f1.4.1.2 while循环,控制循环的变量p,当p!=NULL 时,进入循环
                	f1.4.1.3.1 修改循环变量p中的node成员变量,自减1: p->node = p->node - 1;
    				f1.4.1.3.2 修改代表节点的循环变量p,让p往后走: p = p->next;
    			f1.4.1.4 修改完毕,返回head,结束函数。
                //内在逻辑,不需要修改链表头时,直接返回原先的链表头即可
    		f1.4.2 否则,代表删除失败(比如被删节点的位置输入的过大)
            	那么,返回head
               	//内在逻辑:即使删除失败,我们也不希望链表头发生改变

  2. 代码:
    #include 
    struct Test
    {
        int node;
        struct Test *next;
    };
    void printLink(struct Test *head);
    struct Test* delNode(struct Test *head, int nodePosition);
    int main(int argc, char const *argv[])
    {
        struct Test *head;
        struct Test t1 = {1,NULL};
        struct Test t2 = {2,NULL}; 
        struct Test t3 = {3,NULL};
        struct Test t4 = {4,NULL};
        t1.next = &t2;                 
        t2.next = &t3; 
        t3.next = &t4; 
        head = &t1;
        int nodePosition;
        puts("删除节点以前");
        printLink(head);
        puts("请输入删除哪个节点");
        scanf("%d", &nodePosition);
        head = delNode(head, nodePosition); 
        puts("删除节点以后");
        printLink(head);
        return 0;
    }
    void printLink(struct Test *head) 
    { 
        while(head != NULL){
            printf("%d ", head->node);
            head = head->next;
        }
        putchar('\n');
    }
    struct Test* delNode(struct Test *head, int nodePosition)
    {
        int flag = 0;
        struct Test *p = head;
        if(nodePosition == 1){
            head = head->next;
            p = head;
            while(p != NULL){
                p->node = p->node - 1;
                p = p->next;
            }
            return head;
        }
        while(p->next != NULL){
            if(p->next->node == nodePosition){
                flag = 1;
                p->next = p->next->next;
                break;
            }
            p = p->next;
        }
        if(flag == 1){
            p = p->next;
            while(p != NULL){
                p->node = p->node - 1;
                p = p->next;
            }
            return head;
        }else{
            puts("删除失败");
            return head;
        }
    }

你可能感兴趣的:(链表,数据结构)