# 编写一个函数，计算一个给定的int在链表中出现的次数

2021年3月25日13:14:40 发表评论 843 次浏览

## 本文概述

``````1. Initialize count as zero.
2. Loop through each element of linked list:
a) If element data is equal to the passed number then
increment the count.
3. Return count.``````

## C ++

``````// C++ program to count occurrences in a linked list
#include <bits/stdc++.h>
using namespace std;

class Node {
public :
int data;
Node* next;
};

/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
{
/* allocate node */
Node* new_node = new Node();

/* put in the data */
new_node->data = new_data;

/* link the old list off the new node */

/* move the head to point to the new node */
}

/* Counts the no. of occurrences of a node
{
int count = 0;
while (current != NULL) {
if (current->data == search_for)
count++;
current = current->next;
}
return count;
}

/* Driver program to test count function*/
int main()
{

/* Use push() to construct below list
1->2->1->3->1 */

/* Check the count function */
cout << "count of 1 is " << count(head, 1);
return 0;
}

// This is code is contributed by rathbhupendra``````

## C

``````// C program to count occurrences in a linked list
#include <stdio.h>
#include <stdlib.h>

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

/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push( struct Node** head_ref, int new_data)
{
/* allocate node */
struct Node* new_node = ( struct Node*) malloc ( sizeof ( struct Node));

/* put in the data  */
new_node->data = new_data;

/* link the old list off the new node */

/* move the head to point to the new node */
}

/* Counts the no. of occurrences of a node
int count( struct Node* head, int search_for)
{
int count = 0;
while (current != NULL) {
if (current->data == search_for)
count++;
current = current->next;
}
return count;
}

/* Driver program to test count function*/
int main()
{

/* Use push() to construct below list
1->2->1->3->1  */

/* Check the count function */
printf ( "count of 1 is %d" , count(head, 1));
return 0;
}``````

## Java

``````// Java program to count occurrences in a linked list

class Node {
int data;
Node next;
Node( int d)
{
data = d;
next = null ;
}
}

/* Inserts a new Node at front of the list. */
public void push( int new_data)
{
/* 1 & 2: Allocate the Node &
Put in the data*/
Node new_node = new Node(new_data);

/* 3. Make next of new Node as head */

/* 4. Move the head to point to new Node */
}

/* Counts the no. of occurrences of a node
int count( int search_for)
{
int count = 0 ;
while (current != null ) {
if (current.data == search_for)
count++;
current = current.next;
}
return count;
}

/* Driver function to test the above methods */
public static void main(String args[])
{

/* Use push() to construct below list
1->2->1->3->1  */
llist.push( 1 );
llist.push( 2 );
llist.push( 1 );
llist.push( 3 );
llist.push( 1 );

/*Checking count function*/
System.out.println( "Count of 1 is " + llist.count( 1 ));
}
}
// This code is contributed by Rajat Mishra``````

## python

``````# Python program to count the number of time a given
# int occurs in a linked list

# Node class
class Node:

# Constructor to initialize the node object
def __init__( self , data):
self .data = data
self . next = None

def __init__( self ):

# Counts the no . of occurrences of a node
def count( self , search_for):
count = 0
while (current is not None ):
if current.data = = search_for:
count + = 1
current = current. next
return count

# Function to insert a new node at the beginning
def push( self , new_data):
new_node = Node(new_data)

def printList( self ):
while (temp):
print temp.data, temp = temp. next

# Driver program
llist.push( 1 )
llist.push( 3 )
llist.push( 1 )
llist.push( 2 )
llist.push( 1 )

# Check for the count function
print "count of 1 is % d" % (llist.count( 1 ))

# This code is contributed by Nikhil Kumar Singh(nickzuck_007)``````

## C#

``````// C# program to count occurrences in a linked list
using System;

public class Node {
public int data;
public Node next;
public Node( int d)
{
data = d;
next = null ;
}
}

/* Inserts a new Node at front of the list. */
public void push( int new_data)
{
/* 1 & 2: Allocate the Node &
Put in the data*/
Node new_node = new Node(new_data);

/* 3. Make next of new Node as head */

/* 4. Move the head to point to new Node */
}

/* Counts the no. of occurrences of a node
int count( int search_for)
{
int count = 0;
while (current != null ) {
if (current.data == search_for)
count++;
current = current.next;
}
return count;
}

/* Driver code */
public static void Main(String[] args)
{

/* Use push() to construct below list
1->2->1->3->1 */
llist.push(1);
llist.push(2);
llist.push(1);
llist.push(3);
llist.push(1);

/*Checking count function*/
Console.WriteLine( "Count of 1 is " + llist.count(1));
}
}

// This code is contributed by Arnab Kundu``````

``count of 1 is 3``

O(n)

O(1)

MY_DOOM

.

``````Algorithm
return frequency
increase frequency by 1

## C ++

``````// C++ program to count occurrences in
// a linked list using recursion
#include <bits/stdc++.h>
using namespace std;

struct Node {
int data;
struct Node* next;
};
// global variable for counting frequeancy of
// given element k
int frequency = 0;

/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push( struct Node** head_ref, int new_data)
{
/* allocate node */
struct Node* new_node = ( struct Node*) malloc ( sizeof ( struct Node));

/* put in the data */
new_node->data = new_data;

/* link the old list off the new node */

/* move the head to point to the new node */
}

/* Counts the no. of occurrences of a node
int count( struct Node* head, int key)
{
return frequency;
frequency++;
}

/* Driver program to test count function*/
int main()
{

/* Use push() to construct below list
1->2->1->3->1  */

/* Check the count function */
cout << "count of 1 is " << count(head, 1);
return 0;
}``````

## Java

``````// Java program to count occurrences in
// a linked list using recursion
import java.io.*;
import java.util.*;

// Represents node of a linkedlist
class Node {
int data;
Node next;
Node( int val)
{
data = val;
next = null ;
}
}

class GFG {

// global variable for counting frequeancy of
// given element k
static int frequency = 0 ;

/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */

static Node push(Node head, int new_data)
{
// allocate node
Node new_node = new Node(new_data);

// link the old list off the new node

// move the head to point to the new node

}

/* Counts the no. of occurrences of a node
static int count(Node head, int key)
{
return frequency;
frequency++;
}

// Driver Code
public static void main(String args[])
{

/* Use push() to construct below list
1->2->1->3->1 */

/* Check the count function */
System.out.print( "count of 1 is " + count(head, 1 ));
}
}

// This code is contributed by rachana soma``````

## Python3

``````# Python program to count the number of
# time a given int occurs in a linked list
# Node class
class Node:

# Constructor to initialize the node object
def __init__( self , data):
self .data = data
self . next = None

def __init__( self ):
self .counter = 0

# Counts the no . of occurances of a node
def count( self , li, key):

# Base case
if ( not li):
return self .counter

# If key is present in
# current node, return true
if (li.data = = key):
self .counter = self .counter + 1

# Recur for remaining list
return self .count(li. next , key)

# Function to insert a new node
# at the beginning
def push( self , new_data):
new_node = Node(new_data)

# Utility function to print the
def printList( self ):
while (temp):
print (temp.data)
temp = temp. next

# Driver Code
llist.push( 1 )
llist.push( 3 )
llist.push( 1 )
llist.push( 2 )
llist.push( 1 )

# Check for the count function
print ( "count of 1 is" , llist.count(llist.head, 1 ))

# This code is contributed by
# Gaurav Kumar Raghav``````

## C#

``````// C# program to count occurrences in
// a linked list using recursion
using System;

// Represents node of a linkedlist
public class Node {
public int data;
public Node next;
public Node( int val)
{
data = val;
next = null ;
}
}

class GFG {

// global variable for counting frequeancy of
// given element k
static int frequency = 0;

/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */

static Node push(Node head, int new_data)
{
// allocate node
Node new_node = new Node(new_data);

// link the old list off the new node

// move the head to point to the new node

}

/* Counts the no. of occurrences of a node
static int count(Node head, int key)
{
return frequency;
frequency++;
}

// Driver Code
public static void Main(String[] args)
{

/* Use push() to construct below list
1->2->1->3->1 */

/* Check the count function */
Console.Write( "count of 1 is " + count(head, 1));
}
}

/* This code contributed by PrinciRaj1992 */``````

``count of 1 is 3``

## C ++

``````// method can be used to avoid
// Global variable 'frequency'

/* Counts the no. of occurrences of a node
int count( struct Node* head, int key)
{
return 0;
}``````

## Java

``````// method can be used to avoid
// Global variable 'frequency'

/* Counts the no. of occurrences of a node
{
return 0 ;
}

// This code is contributed by rachana soma``````

## C#

``````// method can be used to avoid
// Global variable 'frequency'
using System;

/* Counts the no. of occurrences of a node
static int count(Node head, int key)
{
return 0;
}

// This code is contributed by SHUBHAMSINGH10``````

## Python3

``````def count( self , temp, key):

# during the initial call, temp
# has the value of head

# Base case
if temp is None :
return 0

# if a match is found, we
# increment the counter
if temp.data = = key:
return 1 + count(temp. next , key)
return count(temp. next , key)

# to call count, use

``````int count(struct Node* head, int key)
{