C语言问题：建立一个有三个结点的链表,然后输出每个结点的数据。
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C语言问题：建立一个有三个结点的链表,然后输出每个结点的数据。相关的知识，希望对你有一定的参考价值。
要求：
建立一个有三个结点的链表，然后输出每个结点的数据。要求每个结点有三个成员：num(char),score(int),next(指针)
请各位高手帮忙啊！
为什么都那么复杂啊，看着就头晕了……
#include "CLinkList.h"
#include "CNode.h"
CLinkList::CLinkList()
cout << "这个是构造函数"<< endl;
m_Head = &m_Node; //链表的头指针指向头结点
m_Node.SetNodeData(0, 0); //给头结点的内容赋0值
m_Node.SetNodeNext(NULL); //将头结点的Next指针设置为NULL;
CLinkList::~CLinkList()
cout << "这个是析构函数" << endl;
void CLinkList::CreateList() //以向后追加的方式创建一个链表，输入0退出
int nScore = 0; //定义一个临时的整形变量来保存数据
char chNum = 0; //定义一个临时的字符型变量来保存数据
cout << "欢迎来创建链表 !" << endl;
CNode * pTemp = NULL; //定义一个临时结点指针，用来增加新结点用
CNode * pNode = m_Head; //定义一个标记指针，首先叫其指向头结点
while(1)
pTemp = new LinkNode;
cout << "请输入下一个结点的内容!" << endl;
cin >> nScore; //输入0退出
cin >> chNum;
if ('0' == nScore)
break;
pTemp->SetNodeData(nScore, chNum); //给新结点的内容赋值
pNode->SetNodeNext(pTemp); //让链尾的Next指向新建的结点
pNode = pTemp; //将结尾元素向后移
cout << "创建链表结束" << endl;
LinkNode* CLinkList::GetListNode(int _nIndex)
cout << "这个是按位置查找指定位结点的成员函数" << endl;
LinkNode* pNode = m_Head->GetNodeNext(); //定义一个临时的结点指针,初始化指向头结点
int Temp = 0; //定义一个临时的变量，用来标记已检查结点的个数的
if(-1 == _nIndex) //返回头结点（即头指针）
return m_Head;
if(_nIndex < -1) //_nIndex控制条件
cout << "您输入的是错误的位置！" << endl;
return 0;
while(pNode != NULL)
if(_nIndex == Temp)
return pNode;
pNode = pNode->GetNodeNext(); //临时结点向后移动
++Temp;
return pNode; //没找到结点就返回NULL
void CLinkList::InsertList(int _nIndex, int _nScore, char _chNum) //插入结点的函数成员
cout << "这个是插入结点的成员函数" << endl;
LinkNode* pNode = GetListNode(_nIndex - 1); //定义一个结点类的指针，指向的是要插入位置的前一指针
LinkNode* pTemp = new CNode; //定义一个临时结点指针，用来增加新结点用
pTemp->SetNodeData(_nScore, _chNum); //设置插入结点的内容
pTemp->SetNodeNext(pNode->GetNodeNext());
pNode->SetNodeNext(pTemp);
void CLinkList::DeleteList(int _nIndex)
cout << "这个是删除某一结点的成员函数" << endl;
LinkNode* pNode = GetListNode(_nIndex - 1); //定义一个结点类的指针，指向的是要删除位置的前一指针
LinkNode* pTemp = NULL; //定义一个临时结点指针，用来指向要删除的结点
pTemp =pNode->GetNodeNext(); //把pTemp指向要删除的结点
pNode->SetNodeNext(pTemp->GetNodeNext()); //把pNode指向要删除的结点的后一个结点
delete pTemp; //删除结点
pTemp = NULL;
LinkNode* CLinkList::GetHeadList()
cout << "这个是获取头指针的成员函数" << endl;
return m_Head;
void CLinkList::SetListData(int _nIndex, int _nScore, char _chNum)
cout << "这个是设置链表中某一结点的值的成员函数" << endl;
CNode *pNode = GetListNode(_nIndex); //定义一个结点类的指针，指向的是要修改内容位置的结点
pNode->SetNodeData(_nScore, _chNum); //修改内容
void CLinkList::ShowListData(int _nIndex)
cout << "这个是显示链表中某一结点值的成员函数" << endl;
CNode *pNode = GetListNode(_nIndex); //定义一个结点类的指针，指向的是要获取内容位置的结点
pNode->ShowNodeData(); //返回想要得到位置的结点内容
void CLinkList::DestroyList(int _nIndex)
cout << "这个是销毁某一位置以后链表的成员函数" << endl;
LinkNode* pTemp = GetListNode(_nIndex - 1); //定义一个结点指针，指向要销毁位置的前一结点
LinkNode* pNode = pTemp->GetNodeNext(); //定义一个结点指针，指向要销毁位置的结点
while(pTemp->GetNodeNext() != NULL) //销毁动作的结束条件或初始条件
pTemp->SetNodeNext(pNode->GetNodeNext()); //把需要销毁的位置的前结点的Next指向销毁位置的下一个结点
delete pNode; //销毁结点
pNode = pTemp->GetNodeNext(); //把pNode重新指向要销毁位置的结点
void CLinkList::ShowList()
cout << "这个是显示链表的成员函数" << endl;
int nTemp = 0; //定义一个临时的整形变量用来控制输入的个数
LinkNode* pTemp = m_Head->GetNodeNext(); //定义一个结点类指针，指向第0位的结点
if(NULL == pTemp)
cout << "这是个空链" << endl;
while(pTemp != NULL)
pTemp->ShowNodeData();
++nTemp;
if(0 == nTemp % 5 && nTemp != 0) //控制每行只能输出5个结点的内容
cout << endl;
pTemp = pTemp->GetNodeNext();
//class CNode
#include "CNode.h"
CNode::CNode()
int m_nScore = 0;
char m_chNum = 0;
m_Next = NULL;
CNode::~CNode()
void CNode::SetNodeData(int _nScore, char _chNum)
m_nScore = _nScore;
m_chNum = _chNum;
void CNode::ShowNodeData()
cout << m_nScore << '\t' << m_chNum << endl;
void CNode::SetNodeNext(CNode* _Next)
m_Next = _Next;
CNode* CNode::GetNodeNext()
return m_Next;
#include "CLinkList.h"
#include "CNode.h"
void Text(); //测试函数声明
int main()
cout << "这是mian函数" << endl;
Text();
return 0;
void Text()
cout << "这个是测试函数" << endl;
LinkList* pList = new LinkList; //创建一个内存链表对象
cout << "------------------CreateList-----------------------------" << endl;
pList->CreateList(); //初始化链表的函数成员
pList->ShowList();
cout << endl;
cout << "------------------GetListNode-----------------------------" << endl;
LinkNode* pNode = NULL; //定义一个临时的结点类指针用于检测查找函数成员
pNode = pList->GetListNode(3); //按位置查找指定位结点的成员函数的测试
if(pNode)
cout << "用按位置查找的方法找到了指定位结点" << endl;
else
cout << "对不起，用按位置查找的方没有找到指定位结点" << endl;
cout << endl;
cout << "------------------InsertList-----------------------------" << endl;
pList->InsertList(0, 9, 'x'); //插入结点的成员函数的测试
pList->ShowList();
cout << endl;
cout << "------------------DeleteList-----------------------------" << endl;
pList->DeleteList(0); //删除某一结点的成员函数的测试
pList->ShowList();
cout << endl;
cout << "------------------GetHeadList-----------------------------" << endl;
pNode = NULL;
pNode = pList->GetHeadList(); //获取头指针的成员函数的测试
if(pNode)
cout << "已经返回了头指针" << endl;
else
cout << "对不起，头指针为空" << endl;
cout << endl;
cout << "------------------GetHeadList-----------------------------" << endl;
pList->SetListData(3, 7 , '@'); //设置链表中某一结点的值的成员函数的测试
pList->ShowList();
cout << endl;
cout << "------------------GetListData-----------------------------" << endl;
cout << "pList->ShowListData(3) =";
pList->ShowListData(3); //获取链中某一结点值的成员函数的测试
cout << endl;
cout << "------------------DestroyList(3)-----------------------------" << endl;
pList->DestroyList(3); //销毁第3位置以后链表的成员函数的测试
pList->ShowList();
cout << endl;
cout << "------------------DestroyList(0)-----------------------------" << endl;
pList->DestroyList(0); //销毁第0位置以后链表的成员函数的测试
pList->ShowList();
cout << endl;
delete pList; //释放内存
pList = NULL; //指针置空
这个是按照我以前写的链表改写的 ， 应该有些功能你用不到 ， 可以删掉的 ， 基本上都有注释的，自己看着改，，后面的很多都是测试程序， 自己看那个不想要也可以删掉 参考技术A //---------------------------------------------------------------------------
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
typedef struct node
char num;
int score;
struct node *next;
node;
node *create(int n) /*创建有n个结点的单链表*/
node *rt=NULL;
node *now;
node *nt=NULL;
int i;
srand(time(NULL));
for (i = 0,rt=now=malloc(sizeof(node)); i<n; i++)
if (i)
nt=malloc(sizeof(node));
nt->next=NULL;
nt->num=rand()%26+'a'; /*对数据域值，此处采用随机数赋值，可以改为从键盘输入*/
nt->score=rand()%101; /*对数据域值，此处采用随机数赋值，可以改为从键盘输入*/
now->next=nt;
now=now->next ;
else
now->num=rand()%26+'a'; /*对数据域值，此处采用随机数赋值，可以改为从键盘输入*/
now->score=rand()%101; /*对数据域值，此处采用随机数赋值，可以改为从键盘输入*/
now->next=NULL;
return rt;
void prt(node *a) /*输出单链表*/
while (a)
printf("NUM:\t\t%c\nSCORE:\t\t%d\n\n",a->num,a->score);
a=a->next;
void nfree(node *a) /*释放空间*/
node *b;
while (a)
b=a->next;
free(a);
a=b;
int main(void)
node *na=create(3); /*调用create()创建包含3个结点的单链表*/
prt(na);
nfree(na);
return 0;
//---------------------------------------------------------------------------本回答被提问者采纳 参考技术B #include<stdio.h>
#include<stdlib.h>
//链表结构类型
typedef struct Node
char num;
int score;
Node* next;
*List;
int main()
List L;
//创建三个结点
Node* l1=(Node*)malloc(sizeof(Node));
Node* l2=(Node*)malloc(sizeof(Node));
Node* l3=(Node*)malloc(sizeof(Node));
//修改三个结点信息
l1->num='1';
l1->score=100;
l2->num='2';
l2->score=85;
l3->num='3';
l3->score=60;
//连接关系
L=l1;
l1->next=l2;
l2->next=l3;
l3->next=NULL;
//循环输出链表信息
Node* p=L;
while(p!=NULL)
printf("num:%c\\n",p->num);
printf("score:%d\\n\\n",p->score);
p=p->next;
//删除链表
free(l1);
free(l2);
free(l3);
return 0;
参考技术C #include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#define MY_MALLOC_TYPEDEF(td) (td *)calloc(1, sizeof(td))
//定义一个结构体
typedef struct node
int age;
char name[64];
struct node *next;
STU;
STU *head, *tail;
STU *createEntry(int age, char *name)
STU *entry;
entry = MY_MALLOC_TYPEDEF(STU);
if(NULL == entry)
return NULL;
entry->age = age;
strcpy(entry->name, name);
//尾插法
if(NULL == head)
head = tail = entry;
return entry;
tail->next = entry;
tail = tail->next;
return entry;
void showList(STU *list)
if(NULL == list)
printf("List is empty!\\n");
return;
while(list)
printf("%s/%d ", list->name, list->age);
list = list->next;
printf("\\n");
int main(int argc, char **argv)
STU *p, *q, *t;
//创建3个节点
q = createEntry(18, "persona");
p = createEntry(19, "personb");
t = createEntry(20, "personc");
showList(head);
return 0;
参考技术D #include<stdio.h>
#include<stdlib.h>
#define LEN sizeof(struct student)
struct student //定义一个结构体student
char num[10];
int score;
struct student *next;//指向下个结点的指针
;
struct student *head;//定义一个链表头指针
void main()
int i;
struct student *p;
for(i=1;i<4;i++)
p=(struct student *)malloc(LEN);
printf("\n请输入学号和成绩:");
scanf("%s%d",p->num,&(p->score));
if(i==1)
head=p;
head->next=NULL;
else if(i==2)
head->next=p;
p->next=NULL;
else
(head->next)->next=p;
p->next=NULL;
p=head;
while(p!=NULL)
printf("\n%10s%5d\n",p->num,p->score);//输出当前结点
p=p->next;//p指向下个结点
c语言程序链表问题
分别建立两个有3个元素结点的单链表（无头结点），然后对两个链表进行各自排序（显示排序后的链表），最后采用首尾相连方式合并两个单链表，显示合并后的单链表。
样例输入
4 6 5
9 7 8
样例输出
4 5 6
7 8 9
4 5 6 7 8 9
虽然题目一个链表只要3元素，但我不想把代码写死，修改常量可实现任意长度链表。
另外你强调不能用头结点，所以我用指向首节点的指针。（头结点只是方便定位链表，和首节点指针其实意义相同，否则你去哪找之前创建好的链表）
#include <malloc.h>
#define LN 3//最大链表元素数量，这里题目只要3个
typedef struct list
int num;
struct list *next;
LIST;
LIST * creatList();
LIST *px(LIST *listP);
void printfLIST(LIST *listP);
LIST *cLists(LIST *listP1,LIST *listP2);
int main()
LIST *listP1=NULL,*listP2=NULL;
printf("输入：\\n");
listP1=creatList();
px(listP1);
listP2=creatList();
px(listP2);
printf("输出：\\n");
printfLIST(listP1);
printfLIST(listP2);
printfLIST(cLists(listP1,listP2));
return 0;
void printfLIST(LIST *listP)//打印链表
while(listP)
printf("%d ",listP->num);
if(listP->next==NULL)
break;
listP=listP->next;
printf("\\n");
LIST * creatList()//输入创建单链表，返回首节点指针
int i=LN;
LIST *listP=NULL,*listTail=NULL;
while(i-->0)
LIST *listNew=(LIST *)malloc(sizeof(LIST));
listNew->next=NULL;
scanf("%d",&listNew->num);
if(listP==NULL)
listP=listNew;
else
listTail->next=listNew;
listTail=listNew;
return listP;
LIST *px(LIST *listP)//排序，返回首节点指针
LIST * listf=listP,*listn=NULL;
while(listf)
listn=listf->next;
while(listn)
if(listf->num>listn->num)
listf->num^=listn->num,listn->num^=listf->num,listf->num^=listn->num;
if(listn->next==NULL)
break;
listn=listn->next;
if(listf->next==NULL)
break;
listf=listf->next;
return listP;
LIST *cLists(LIST *listP1,LIST *listP2)//连接两个链表，返回首节点指针
LIST *listP3=listP1;
while(listP1)
if(listP1->next==NULL)
break;
listP1=listP1->next;
listP1->next=listP2;
return listP3;
参考技术A 操作系统 win 8.1// 编译环境 Visual Stuido 2017#include<stdio.h>#include<malloc.h>#include<stdlib.h>typedef int ElementType; // 定义数据类型,可根据需要进行其他类型定义 // 链表节点的定义typedef struct ListNode
ElementType Element; // 数据域，存放数据
ListNode* Next; // 指向下一个链表节点Node, *PNode;// 链表创建函数定义PNode CreateList(void) int len ; // 用于定义链表长度
int val ; // 用于存放节点数值
PNode PHead = (PNode)malloc(sizeof(Node)); // 创建分配一个头节点内存空间
//头节点相当于链表的哨兵，不存放数据，指向首节点（第一个节点）
if (PHead == NULL) // 判断是否分配成功
printf("空间分配失败 \n");
exit(-1);
PNode PTail = PHead; // 链表的末尾节点，初始指向头节点
PTail->Next = NULL; // 最后一个节点指针置为空
printf("请输入节点个数：");
scanf_s("%d", &len); // 输入节点个数
for (int i = 0; i < len; i++)
PNode pNew = (PNode)malloc(sizeof(Node)); // 分配一个新节点
if (pNew == NULL)
printf("分配新节点失败\n");
exit(-1);
printf("请输入第 %d 个节点的数据：", i + 1);
scanf_s("%d", &val); // 输入链表节点的数据
pNew->Element = val; // 把数据赋值给节点数据域
PTail->Next = pNew; // 末尾节点指针指向下一个新节点
pNew->Next = NULL; // 新节点指针指向为空
PTail = pNew; // 将新节点复制给末尾节点
printf("创建链表成功\n"); return PHead; // 返回头节点// 主函数 int main()
PNode List = CreateList(); //创建一个指针，使其指向新创建的链表的头指针
return 0;
参考技术B 你的这个要求不会有人答应的。因为：（1）、你的这个题目难度很大，首先从程序的编程难度和规模上讲，比老师留的一个 C 语言大作业还大，更何况在你的要求中还涉及到了 C 语言的最精华、同时也是最、最难于调试的程序代码：指针！！因为指针在 C 语言中是一个极其重要、且非常抽象的概念，况且如果再将涉及到的指针的相关知识，应用于建立、删除、排序各种链表（即：单链表一个指针变量、或者是：双链表两个指针变量）、并且调试通过这类的源代码，那就更是难上加难的事情！
（2）、此外必须要知道：编写任何一个高级语言源程序，要想从编程、编译、调试、直到最后运行出正确的结果，那是必须要有一个上机编程环境，且经过亲自上机调试，而不是靠在纸上写完程序，就一定能够保证程序运行出正确结果的。
以上是关于C语言问题：建立一个有三个结点的链表,然后输出每个结点的数据。的主要内容，如果未能解决你的问题，请参考以下文章
C语言问题：建立一个由3个学生数据组成的单向动态链表，向每个结点输入学生的数据（学号姓名成绩）逐个输出