7-6-1 求单链表的表长 (10 分)（函数题）

最新推荐文章于 2023-01-07 17:18:03 发布
最新推荐文章于 2023-01-07 17:18:03 发布
阅读量2.1k 收藏 6
点赞数
分类专栏： c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50934744/article/details/115952574
版权

7-6-1 求单链表的表长 (10 分)
本题要求实现一个函数，求带头结点的单链表的表长。

函数接口定义：

int Length ( LinkList L );

其中LinkList结构定义如下：

typedef struct LNode
{
   
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

L是带头结点的单链表的头指针，函数Length返回单链表的长度。

裁判测试程序样例：


                

                
                
        

        

    




        

            

                    
                      最低0.47元/天 解锁文章
                        
                    
            

        

    

      

        

            

              
                
                  静！
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    6
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
顺序栈的置空入栈出栈和返回栈顶元素

				
			

			

				

					beyond161的专栏
				

				

					11-01
					
					3940
					
				

			

		

		

			
				
#include "stdio.h"
#include "stdlib.h"
#define MAXSIZE 100
#define OK 1
#define FALSE 0
//顺序栈结构体
typedef struct stack{
int data[MAXSIZE];
int top;
}*pstack, stack;


//置空顺序栈
int empty(pst

			
		

	



                

              
                



	

		

			

				
					
程序填空题

				
			

			

				

					大家一起入坑
				

				

					12-26
					
					5629
					
				

			

		

		

			
				
5-1

链栈入栈出栈操作。


#include<iostream>
using namespace std;

typedef char SElemType;

typedef struct StackNode {
    SElemType data;
    struct StackNode *next;
} StackNode, *LinkStack;


int Push(LinkStack &S, SElemType e) {
    LinkStack p;
    p 

			
		

	



                


  
              

                


	

		

			

				
					
数据结构5 栈和队列

				
			

			

				

					ohuojiuwo的博客
				

				

					01-07
					
					1868
					
				

			

		

		

			
				
若用一个大小为6的数组来实现循环队列，且当前rear和front的值分别为0和3，当从队列中删除一个元素，再加入两个元素后，rear和front的值分别为( )在堆栈S上运行以下操作：Push（S，1）、Push（S，2）、Pop（S）、Push（S，3）、Pop（S）和Pop（S）。如果按顺序｛1，2，3，4，5｝将键推到堆栈上，则不可能获得输出序列｛3，4、1，2、5｝。设一数列的顺序为1，2，3，4，5，6，通过队列操作可以得到（ ）的输出序列。给定堆栈的弹出顺序为｛1，2，3，4，5，6｝。

			
		

	





	

		

			

				
					
实验11-2-8 单链表结点删除 (20分)

				
			

			

				

					u014390786的博客
				

				

					09-10
					
					2155
					
				

			

		

		

			
				
本题要求实现两个函数，分别将读入的数据存储为单链表、将链表中所有存储了某给定值的结点删除。链表结点定义如下：
struct ListNode {
int data;
ListNode *next;
};
函数接口定义：
struct ListNode *readlist();
struct ListNode *deletem( struct ListNode *L, int m );
函数readlist从标准输入读入一系列正整数，按照读入顺序建立单链表。当读到−1时表示输入结束，函数应返回指向单链表头结点

			
		

	



		

			
		



	

		

			

				
					
牛客网:删除链表中的重复结点(图文并茂)

				
			

			

				

					zw的博客
				

				

					02-17
					
					467
					
				

			

		

		

			
				
题目描述
删除链表中的重复结点
在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。
示例1：

输入：{1,2,3,3,4,4,5}
输出：{1,2,5}

题解
本题可采用三个指针，指针prev用来包存前一个结点的信息，指针tail 和 tmp 用来寻找重复结点。(因为链表是已经排好序的，所有重复结点一定排在一起)

初始情况

①当tail -> val 和 tmp -> val 不相同时，更新这三个指针的位置，则prev = tmp 、tmp 

			
		

	





	

		

			

				
					
6-1 求链式表的表长 （10 分）

				
			

			

				

					南风的博客
				

				

					11-18
					
					1万+
					
				

			

		

		

			
				
本题要求实现一个函数，求链式表的表长。
函数接口定义：
int Length( List L );

其中List结构定义如下：
typedef struct LNode *PtrToLNode;
struct LNode {
    ElementType Data;
    PtrToLNode Next;
};
typedef PtrToLNode List;

L是给定单链表，函数Leng...

			
		

	





	

		

			

				
					
数据结构C语言版章节练习题(1-6章).doc

				
			

			

				

					11-15
				

			

		

		

			
				
数据结构C语言版章节练习题（1-6章）  本资源摘要信息涵盖了数据结构的基本概念、线性表、树形结构、图形结构、栈、队列、树、图等知识点，并且结合C语言实现提供了一系列章节练习题，旨在帮助读者更好地理解和掌握...

			
		

	





	

		

			

				
					
2022届-JAVA开发笔试题.docx

				
			

			

				

					12-19
				

			

		

		

			
				
1. JAVA基本语法：变量声明、数据类型、运算符、控制结构、函数等。 2. JAVA对象oriented programming：类、对象、继承、多态、抽象类、接口等。 3. JAVA异常处理：try-catch块、finally块、throw和throws关键字等。...

			
		

	





	

		

			

				
					
206-习题作业-作业十五1

				
			

			

				

					08-04
				

			

		

		

			
				
1. 函数定义：`template<class T> node<T> *find(node<T> *head, const T &x)`，这里使用了模板类，可以处理任何类型的数据，`find`函数接收一个链表头结点和要查找的元素值。  2. 初始化指针`p`为`head`，开始遍历...

			
		

	





	

		

			

				
					
java-leetcode题解之第234题回文链表.zip

				
			

			

				

					06-05
				

			

		

		

			
				
本压缩包"java-leetcode题解之第234题回文链表.zip"包含了对LeetCode第234题的Java解决方案。这道题目涉及到链表操作，特别是关于判断一个链表是否是回文结构的关键概念。  **234题：回文链表**  题目描述：给定一个...

			
		

	





	

		

			

				
					
python-leetcode面试题解之第369题给单链表加一.zip

					
最新发布

				
			

			

				

					06-26
				

			

		

		

			
				
题目编号为第369题，题目是“给单链表加一”。这是一道涉及数据结构和算法的问题，主要考察的是链表操作和数值计算。接下来，我们将深入探讨这个题目以及它的解决方案。  首先，我们要理解链表是什么。链表是一种...

			
		

	





	

		

			

				
					
“删除链表中重复的结点”

				
			

			

				

					yizhizainulii的博客
				

				

					12-29
					
					2573
					
				

			

		

		

			
				
描述

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表 1->2->3->3->4->4->5 处理后为 1->2->5

数据范围：链表长度满足，链表中的值满足

进阶：空间复杂度，时间复杂度

例如输入{1,2,3,3,4,4,5}时，对应的输出为{1,2,5}，对应的输入输出链表如下图所示：



示例1


输入：{1,2,3,3,4,4,5}

返回值：{1,2,5}


...

			
		

	





	

		

			

				
					
数据结构:求单链表(有头节点)长度

					
热门推荐

				
			

			

				

					匿名攻城狮
				

				

					03-13
					
					2万+
					
				

			

		

		

			
				
- 单链表的长度求法与顺序表不同(顺序表有现成的函数length()),下面是求单链表长度的两种方法。
方法一:
Status Length_L(LinkList L,int &amp;e)
{
	LinkList p=L-&gt;next;//定义头指针 
	int j=1;//定义j来计数
	while(p)//while(p!=NULL) 
	{
		p=p-&gt;next;//指针向.........

			
		

	





	

		

			

				
					
删除链表中重复的结点（牛客）

				
			

			

				

					weixin_43520256的博客
				

				

					02-20
					
					206
					
				

			

		

		

			
				
删除链表中重复的结点
在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5
示例1
输入
{1,2,3,3,4,4,5}
输出
{1,2,5}
解析：
首先判空，如果输入链表为空或链表只有一个结点则返回原链表
然后创建一个头结点，避免出现第一个结点和第二个节点相同
遍历链表，用双指针进行拼接
class Solution
{
    publ

			
		

	





	

		

			

				
					
【数据结构1】有序单链表删除重复节点

				
			

			

				

					weixin_60125979的博客
				

				

					04-09
					
					1628
					
				

			

		

		

			
				
1.判断要几个临时节点：1/2/3

2.思路：1.假如该链表中要删除的数是连续存放的，且头几个节点连续的话，要维护这个链          表需要的节点多，删除也不是很方便的。

       2.干脆新起一个链表，把非重复的节点接在这个节点的后面（有头/无头）

      3.那么就可以用原链表的头来遍历原链表，根本不用更多的节点。符合要求的节点        就连到新链表上去

3.就设一个无头的链表： Node newHead =...

			
		

	





	

		

			

				
					
删除单链表中的重复节点（删除重复项）

				
			

			

				

					小僧Coding
				

				

					06-20
					
					7077
					
				

			

		

		

			
				
题目：删除单链表中的重复节点（删除重复项；即只要链表中某个元素的出现次数大于1，那么就将链表中所有的该元素都删除）（即重复的结点不保留） 
例如，链表1->3->2->5->6->1->5->7->3->8->2 ，处理后为 6->7->8。 
思路分析： 
只需在删除单链表中的重复节点（删除多余项）的非递归方法上略作修改即可实现。但是要注意，带头节点的单链表和不带头节点的单链表的细微区别。 
具体

			
		

	





	

		

			

				
					
数据结构：队列链表，此代码有初始化、入队、出队、判断队是否为空

				
			

			

				

					qq_41631679的博客
				

				

					11-04
					
					1085
					
				

			

		

		

			
				
数据结构队列链表，此代码有初始化、入队、出队、判断队是否为空，可以直接copy调试。
#include"stdio.h"
#include"stdlib.h"

typedef struct node * pointer;

struct node{
	int data;
	pointer next;
};

typedef struct 
{
	pointer front,rear;
}queu...

			
		

	





	

		

			

				
					
7-7 验证“哥德巴赫猜想” (20 分)

				
			

			

				

					weixin_50934744的博客
				

				

					03-10
					
					7582
					
				

			

		

		

			
				
7-7 验证“哥德巴赫猜想” (20 分)
数学领域著名的“哥德巴赫猜想”的大致意思是：任何一个大于2的偶数总能表示为两个素数之和。比如：24=5+19，其中5和19都是素数。本实验的任务是设计一个程序，验证20亿以内的偶数都可以分解成两个素数之和。
输入格式：
输入在一行中给出一个(2, 2 000 000 000]范围内的偶数N。
输出格式：
在一行中按照格式“N = p + q”输出N的素数分解，其中p ≤ q均为素数。又因为这样的分解不唯一（例如24还可以分解为7+17），要求必须输出所有解中p最小

			
		

	





	

		

			

				
					
本题要求实现一个函数，求带头结点的单链表的表长。

				
			

			

				

					09-14
				

			

		

		

			
				
### 回答1：
可以遍历整个单链表，统计节点个数即为表长。具体实现如下：

```python
def get_list_length(head):
    """
    获取带头结点的单链表的表长
    """
    length = 0
    cur = head.next
    while cur:
        length += 1
        cur = cur.next
    return length
```

其中，head 是带头结点的单链表的头结点。我们通过 head.next 获取实际存储数据的第一个节点，然后循环遍历链表，每经过一个节点 length 加 1，直到遍历到链表末尾。最后返回 length 即为表长。  

### 回答2：
单链表是一种链式存储结构，由节点组成，每个节点包含一个数据域和一个指针域。而带头结点的单链表是在链表的第一个节点之前设置一个额外的头结点，目的是方便链表的操作和统一代码逻辑。求带头结点的单链表的表长，即计算链表中节点的数量。

具体实现如下：

1. 定义一个函数 `getLength`，用来求带头结点的单链表的表长。

2. 在函数中，创建一个变量 `length` 并初始化为0，用于记录链表的长度。

3. 判断头结点的指针域是否为空，即链表是否为空。

4. 若为空，说明链表中没有节点，直接返回长度为0。

5. 若不为空，说明链表中至少有一个节点，进入循环。

6. 在循环中，每次将节点的指针域赋值给当前节点，再将当前节点的指针域赋值给下一个节点，即遍历到下一个节点。

7. 每次循环，计数器 `length` 加1，直到链表的最后一个节点的指针域为空。

8. 返回计数器 `length`，即为带头结点的单链表的表长。

这样，就实现了求带头结点的单链表的表长的函数。

例如，以下是一个带头结点的单链表的表长的示例代码：

```
typedef struct Node {
    int data;
    struct Node* next;
} Node;

int getLength(Node *head) {
    int length = 0;
    Node *current = head->next;  // 当前节点指向第一个节点

    while (current != NULL) {
        current = current->next;
        length++;
    }

    return length;
}
```  

### 回答3：
题目要求实现一个函数，用于求解带头结点的单链表的表长。

解答如下：

```python
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

def get_length(head):
    # 表长初始化为0
    length = 0 
    # 当前结点指向头结点的下一个结点
    cur = head.next 
    while cur:
        # 遍历链表，每经过一个结点，表长加1
        length += 1
        cur = cur.next
    return length
```

首先，我们需要定义一个Node类，用于表示链表的结点。每个结点包括两部分：数据项和指向下一个结点的指针。

接着，我们定义了一个get_length函数，用于求解带头结点的单链表的表长。我们将表长初始化为0，然后遍历链表，每经过一个结点，表长加1。遍历链表的过程是不断将当前结点指向下一个结点，直到当前结点为None，表示已经遍历到了链表的尾部。最后，函数返回表长。

使用该函数可以方便地求解带头结点的单链表的表长。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值