链表的可变参数构造与图的临接表实现   广度有限遍历

 
#include <bits/stdc++.h>
using namespace std;
typedef  struct node
{
  int x; 
  node*next;
  node(){next=NULL;}
}node;
typedef struct head
{
    int x;
    int count;
    node*head;
    //head(int xx,int cc,node* P=NULL){x=xx;count=cc;head=p;}
}head;

void InsertTail(node *head,int val)
{
	if(head == NULL)
		return ;
	node *tmp = (node *)malloc(sizeof(node)*1);
	tmp->next = NULL;
	tmp->x = val;
	while(head->next != NULL)
	{
		head = head->next;
	}
	head->next = tmp;
}

/* VS2008*/
void List(node *head,...)
{
	if(head == NULL) return ;
	char* p = (char *)&head+4;
	int n = *(int *)p;
	int x = 0;
	for(int i=0;i < n;++i)
	{
		p = p+sizeof(int);
		x = *(int *)p;
		InsertTail(head,x);
	}

}
void show(node*head)
{
  node *p = head->next;    
    while(p != NULL)
    {
        cout<<p->x<<" ";
        p = p->next;
    }
    cout<<endl;
}
int  test()
{
    head   H[11];
    node *head0  = (node *)malloc(sizeof(node));
    node *head1  = (node *)malloc(sizeof(node));
    node *head2  = (node *)malloc(sizeof(node));
    node *head3  = (node *)malloc(sizeof(node));
    node *head4  = (node *)malloc(sizeof(node));
    node *head5  = (node *)malloc(sizeof(node));
    node *head6  = (node *)malloc(sizeof(node));
    node *head7  = (node *)malloc(sizeof(node));
    node *head8  = (node *)malloc(sizeof(node));
    node *head9  = (node *)malloc(sizeof(node));
   node *head10  = (node *)malloc(sizeof(node));
    List(head0,1,1);         H[0].head=head0;   
    List(head1,2,2,10);      H[1].head=head1;    
    List(head3,2,2,4);       H[3].head=head3;    
    List(head5,2,4,6);       H[5].head=head5;    
    List(head7,2,6,8);       H[7].head=head7;    
    List(head9,2,8,10);      H[9].head=head9;    
    List(head2,4,2,3,4,10);  H[2].head=head2;    
    List(head4,4,2,3,5,6);   H[4].head=head4;    
    List(head6,4,4,5,7,8);   H[6].head=head6;     
    List(head8,4,6,7,9,10);  H[8].head=head8;    
    List(head10,4,1,2,8,9); H[10].head=head10;
     for(int i=1;i<=10;i++)
    {
     H[i].x=i;H[i].count=(i%2)?2:4;     
    } 
   // show(head1);show(head2);show(head3);show(head4);show(head5);
  //  show(head6);show(head7);show(head8);show(head9);show(head10);
   
  queue<head>q;
  vector<int>v;
   q.push(H[0]);
  while(!q.empty())
    {
   head h=q.front();
      node*p=h.head->next;
      while(p!=NULL)
       {
          if(find(v.begin(),v.end(),p->x)==v.end())
          {
            cout<<p->x<<"   ";
            v.push_back(p->x);
            q.push(H[p->x]);
          }          
          p=p->next;
       } 
    q.pop();    
    }
 cout<<endl;
  
	return 0;
}
int main()
{
    test();
    
	cout << "Hello,C++ world of AnycodeX!" << endl;
	return 0;
}

五角星

特别说明

这里的代码  anycodes编译不过

需要设计一个通用的可变参,初始化链表;

时间: 2024-10-06 20:17:49

链表的可变参数构造与图的临接表实现   广度有限遍历的相关文章

可变参数函数详解

可变参数函数又称参数个数可变函数(本文也简称变参函数),即函数参数数目可变.原型声明格式为: type VarArgFunc(type FixedArg1, type FixedArg2, -); 其中,参数可分为两部分:数目确定的固定参数和数目可变的可选参数.函数至少需要一个固定参数,其声明与普通函数参数相同:可选参数由于数目不定(0个或以上),声明时用"-"表示("-"用作参数占位符).固定参数和可选参数共同构成可变参数函数的参数列表. 由于参数数目不定,使用可

Python的三种可变参数

初学python没多久,对python中函数的可变参数有点头晕,查阅了stackflow,现总结一下可变参数 可变参数应该最简单,在C/C++和Java等语言中都有,就是用*号来表示,例如 def testArg(*arg) 你可以传入任意多个元素(包括0)到参数中,在函数内部会自动认为是一个元组或列表 关键字参数 关键字参数在python中习惯用**kw表示,可以传入0到任意多个“关键字-值”,参数在函数内部被当做一个字典结构.例如 def testArg(**kw) def testArg(

java map接口,可变参数,Collections集合工具类

map接口的实现类存储成对的值,键--值.通过键来找到对应的值. Collection中的集合称为单列集合,Map中的集合称为双列集合 Map中常用的集合为HashMap集合.LinkedHashMap集合. HashMap<K,V>:存储数据采用的哈希表结构,元素的存取顺序不能保证一致.由于要保证键的唯一.不重复,需要重写键的hashCode()方法.equals()方法. LinkedHashMap<K,V>:HashMap下有个子类LinkedHashMap,存储数据采用的哈

编写一个可变参数的C函数——头文件stdarg.h中宏va_start ,va_arg和va_end的应用

我们在C语言编程中会遇到一些参数个数可变的函数,例如printf()这个函数,它的定义是这样的:int printf( const char* format, ...);它除了有一个参数format固定以外,后面跟的参数的个数和类型是可变的,例如我们可以有以下不同的调用方法:printf("%d",i);printf("%s",s);printf("the number is %d ,string is:%s", i, s);究竟如何写可变参数的

接口,泛型,可变参数在代码向上抽去中的应用探究

JAVA作为一种面向对象的语言,类和对象可以说是搭建起JAVA体系的基本框架,我们可以将类看做是对众多实体对象共性的向上抽取,而接口则是对类共性的向上抽取,我将接口理解为一种规则,一种规范,同时也是多态的应用中我们作为形式参数传递的最顶层的父类,因此接口的功能非常强大(能装B),我们在sun公司定义的API中可以经常看到它的身影,它也是架构师手中搭建框架的利器,因此以后我们会经常使用到它(能装B). ------------------------------------------------

C++11中的Tuple和可变参数模版

C++11中的tuple是一个n元的可变元组,它相当于有n个元素的结构体,只不过这个结构体的成员都是匿名的,tuple中提供了一个get()方法来获取某个下标对应的元素的值.另外可以通过make_tuple()方法来构造一个tuple对象.具体用法如下 我们知道tuple中的元素个数是不确定的,而每个元素的类型通过模板参数指定,那么tuple是如何做到这些的呢?答案就是使用可变参数模板.在C++中,我们使用过printf函数,它的参数就是可变的,在C++11中也允许模板的参数也是可变的.举个例子

C# 中的可变参数方法(VarArgs)

首先需要明确一点:这里提到的可变参数方法,指的是具有 CallingConventions.VarArgs 调用约定的方法,而不是包含 params 参数的方法.可以通过MethodBase.CallingConvention 属性来获取某个方法的调用约定. 举个常见的例子来说,C 语言的 printf 方法大多数人应该都知道,它的作用是向标准输出流(stdout)写入格式化字符串,printf 的方法签名是: int printf(const char * format, ...); 方法签名

黑马程序员——【Java高新技术】——JDK1.5新特性:静态导入、可变参数、增强型for循环、自动装箱拆箱、枚举

一.静态导入 1.import和import static区别: (1)import 是导入一个类或某个包中所有的类. (2)import static是导入一个类中的某个静态方法或所有的静态方法. 注:在调用静态导入的类的静态方法时,可以不用再写类名.如Arrays.sort(int[])可以直接写sort(int[]); 2.静态导入的写法: (1)import static java.util.Arrays.*;   表示导入Arrays类中的所有静态成员. (2)import stati

可变参数模板

一.基本语法 声明一个带有可变参数个数的模板的语法如下所示: template<typename ...Element> class tuple; tuple<int, string> a;  // use it like this 在模板参数 Element 左边出现省略号 ... ,就是表示 Element 是一个模板参数包(template type parameter pack).parameter pack(参数包)是新引入 C++ 中的概念,比如在这个例子中,Eleme