链表c语言经典例题,求写C语言 创建链表实例子。要最基本的 包括注释。
链表c语言经典例题,求写C语言 创建链表实例子。要最基本的 包括注释。详细介绍
本文目录一览： 求写C语言 创建链表实例子。要最基本的 包括注释。
#include
#include
typedef int datatype;typedef struct node { // 结点数据类型声明 datatype info; struct node *next;}NODE;void show(NODE *head) { // 有头结点循环链表的显示 NODE *p; for(p = head->next; p != head; p = p->next) printf("%d ",p->info); printf("\n");}NODE *josefnode(int n) { // 创建有头结点的n个结点的单向循环链表 int i; NODE *p, *head; head = p = (NODE *)malloc(sizeof(NODE)); // 首先生成头结点 head->info = 0; // 头结点的数据域初始化为0，非必要 for(i = 0; i < n; ++i) { p->next = (NODE *)malloc(sizeof(NODE)); // 得到新结点存储空间 p->next->info = i + 1; // 给新结点数据域赋值 p = p->next; // 移动指针 } p->next = head; // 尾结点的next指向头结点(head) return head; // 返回头结点地址}// 报名出列代码，有些难度void josef(int n) { // int cnt = 0; NODE *h, *p, *q; h = p = josefnode(n); // 获取链表 show(h); // 显示链表信息 while(h->next != h) { // 循环点名代码，直到有效结点个数为0 if(p->next == h) p = p->next; // 遇到头结点则跳过 ++cnt; // 点名计数器增1 if(cnt % 3 == 0) { // 满足3的倍数时 q = p->next; // q指向该结点 printf("%d ",q->info); // 显示该结点数据 p->next = q->next; // 计数指针移到下一个结点 free(q); // 删除结点 } else p = p->next; // 非3 的整数倍时，继续 } printf("\n"); free(h); // 释放头结点 h = NULL;}void main() { int n; printf("请输入人数:"); scanf("%d", &n); josef(n);}
题目：创建固定长度的单向链表
程序分析：链表是动态分配存储空间的链式存储结构，
其包括一个“头指针”变量，其中第0个结点称为整个链表的头结点，头结点中存放一个地址，该地址指向一个元素，头结点一般不存放具体数据，只是存放第一个结点的地址。
链表中每一个元素称为“结点”，每个结点都由两部分组成：存放数据元素的数据域和存储直接后继存储位置的指针域。指针域中存储的即是链表的下一个结点存储位置，是一个指针。多个结点链接成一个链表。
最后一个结点的指针域设置为空(NULL)，作为链表的结束标志，表示它没有后继结点。
使用结构体变量作为链表中的结点，因为结构体变量成员可以是数值类型，字符类型，数组类型，也可以是指针类型，这样就可以使用指针类型成员来存放下一个结点的地址，使其它类型成员存放数据信息。
在创建列表时要动态为链表分配空间，C语言的库函数提供了几种函数实现动态开辟存储单元。
malloc()函数实现动态开辟存储单元：
malloc函数原型为：void *malloc(unsigned int size); 其作用是在内存的动态存储区中分配一个长度为size的连续空间，函数返回值是一个指向分配域起始地址的指针（类型为void）。如果分配空间失败（如，内存空间不足），则返回空间指针（NULL）
#include
#include
struct LNode{int data;struct LNode *next;};/*上面只是定义了一个结构体类型，并未实际分配内存空间只有定义了变量才分配内存空间*/struct LNode *creat(int n){int i;struct LNode *head,*p1,*p2;/*head用来标记链表，p1总是用来指向新分配的内存空间，p2总是指向尾结点，并通过p2来链入新分配的结点*/int a;head=NULL;for(i=1;i<=n;i++){p1=(struct LNode *)malloc(sizeof(struct LNode));/*动态分配内存空间，并数据转换为(struct LNode)类型*/printf("请输入链表中的第%d个数：",i);scanf("%d",&a);p1->data=a;if(head==NULL)/*指定链表的头指针*/{head=p1;p2=p1;}else{p2->next=p1;p2=p1;}p2->next=NULL;/*尾结点的后继指针为NULL(空)*/}return head;/*返回链表的头指针*/}void main(){int n;struct LNode *q;printf("请输入链表的长度：/n");scanf("%d",&n);q=creat(n);/*链表的头指针(head)来标记整个链表*/printf("/n链表中的数据：/n");while(q)/*直到结点q为NULL结束循环*/{printf("%d ",q->data);/*输出结点中的值*/q=q->next;/*指向下一个结点*/}}
链表习题（C语言）
设链表长度为n，找到倒数第m个元素(约定0为最后一个元素)，也就是找到正数第n - m - 1个元素，计数方法当然也是从0开始。
#include
#include
typedef int DataType;typedef struct list { DataType elem; struct list *next;}*LIST,*pNode;LIST InitList() { LIST L = (pNode)malloc(sizeof(struct list)); L->elem = 0; L->next = NULL; return L;}void CreateList(LIST L, DataType a[], int n) { int i; pNode p = L; for(i = 0; i < n; ++i) { p->next = (pNode)malloc(sizeof(struct list)); p->next->elem = a[i]; p = p->next; } p->next = NULL;}int lenList(LIST L) { // 求取表长 int len = 0; pNode p = L->next; // 有头结点 while(p) { ++len; p = p->next; } return len;}int GetData(LIST L,int m,DataType *e) { int i = -1,len = lenList(L); pNode p = L->next; if(m < 0 || m > len - 1) { printf("没有第 %d 个元素。\n",m); return 0; } while(i < len - m - 1) { ++i; p = p->next; } *e = p->elem; return 1;}int main() { DataType arr[] = {16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1}; int n,m,res; LIST L = InitList(); n = sizeof(arr)/sizeof(arr[0]); CreateList(L,arr,n); while(scanf("%d",&m) == 1) { if(GetData(L,m,&res)) printf("倒数第 %d 元素是:%d.\n",m,res); } return 0;}
链表基本操作练习（C语言）
说真的,你的分数太少了.当我弄了一半的时候才觉得有点不值,但又不想半途而废,最终还是帮你做了,所以希望你能及时采纳,这可是我弄了好久的呀!
好了,最后还帮你修改了一遍,已经编译通过的了.并且检查过可以完成你说的功能的了.
#include
#include
typedef struct list
{
int num;struct lst *next;
} LST;
LST *mycreat()
{
int data=0;
LST *head=NULL,*p=NULL,*q=NULL;
head=(LST*)malloc(sizeof(LST));
q=head;
printf("请输入链表数据(整型)并以空格空开,以-1为最后一个数,回车结尾:\n");
scanf("%d",&data);
while(data!=-1)
{
p=(LST*)malloc(sizeof(LST));
q->next=p;
p->num=data;
q=p;
scanf("%d",&data);
}
q->next=NULL;
return head;
}
void mycheck(LST *head)
{
int i=0,x=0;
LST *p=NULL;
printf("\n请输入要查询的结点:\n");
scanf("%d",&x);
p=head;
while(p!=NULL)
if(i!=x)
{
p=p->next;
i++;
}
else break;
if(p!=NULL)printf("\nthe %d node is %d\n",x,p->num);
else printf("\n there is no this node\n");
}
int mydelete (LST* head,int m)
{
LST *p=NULL,*q=NULL;
q=head;
p=head->next;
while(p!=NULL)
if(m!=p->num)
{
q=q->next;
p=p->next;
}
else break;
if(p==NULL) return 0;
q->next=p->next;
free(p);
return 1;
}
void myprint(LST *head)
{
LST *p=NULL;
p=head->next;
if(p==NULL)printf("\n empty list!");
else
do
{
printf("\n%5d\n",p->num);
p=p->next;
}while(p!=NULL);
printf("\n");
}
int thelength(LST *head)
{
int length=0;
LST *p=NULL;
p=head;
while(p!=NULL)
{
p=p->next;
length++;
}
return length;
}
void clear(LST *head)
{
LST *p=NULL;
p=head;
while(p->next!=NULL)
{
p=p->next;
p->num=0;
}
}
main()
{
int k=0,m=0,l=0;
LST *head=NULL;
head=mycreat();
mycheck(head);
printf("to delete list:");
scanf("%d",&m);
k=mydelete(head,m);
if(k==1)
{
printf("after deleting");
myprint(head);
}
else printf("not exist.\n");
l=thelength(head);
printf("the length is %d",l);
clear(head);
}
C语言问题：建立一个有三个结点的链表,然后输出每个结点的数据。
//---------------------------------------------------------------------------
#include
#include
#include
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;
}
//---------------------------------------------------------------------------
#include
#include
//链表结构类型 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;}
#include
#include
#include
#include
#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;}
#include
#include
#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指向下个结点
}
}
#include
struct Node{ char num[10]; int score; struct Node *next;//(指针)};int main (void){ struct Node tt[3] ={ {"111",66,&tt[1]},{"222",77,&tt[2]},{"333",88,NULL}}; struct Node *p; p = tt; while(p) { printf("%d\n",p->score); p = p->next; } return 0;}667788Press any key to continue我来个简单的 静态三个节点的链表 网上那些动态链表是有些复杂
//class CLinkList
#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; //指针置空
}
这个是按照我以前写的链表改写的 ， 应该有些功能你用不到 ， 可以删掉的 ， 基本上都有注释的，自己看着改，，后面的很多都是测试程序， 自己看那个不想要也可以删掉
C语言，创建一个链表并赋值1、2、3、4、5，麻烦把全部程序写下
// DLink.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include "malloc.h"
typedef struct LNode
{
int data;
struct LNode *next;
}Dlink;
int _tmain(int argc, _TCHAR* argv[])
{
Dlink *l,*s1;
Dlink *s=(Dlink *)malloc(sizeof(Dlink));
l=s;
for(int i=0;i<5;i++)
{
s->data=i+1;
s1=(Dlink *)malloc(sizeof(Dlink));
s->next=s1;
s=s1;
}
s->next=NULL;
//数据就保存到以l为头结点的链表中了
return 0;
}
扩展资料：
对于非线性的链表，可以参见相关的其他数据结构，例如树、图。另外有一种基于多个线性链表的数据结构：跳表，插入、删除和查找等基本操作的速度可以达到O(nlogn），和平衡二叉树一样。
其中存储数据元素信息的域称作数据域（设域名为data），存储直接后继存储位置的域称为指针域（设域名为next）。指针域中存储的信息又称做指针或链。
由分别表示,，?，的N 个结点依次相链构成的链表，称为线性表的链式存储表示，由于此类链表的每个结点中只包含一个指针域，故又称单链表或线性链表。
C语言程序题：两个有序单链表的合并 合并之后仍然有序。 如第一个链表13579 第二个链表
#include
#include
struct list{ int data; struct list *next;};//两个链表融合，插入排序函数void sort(struct list *l1,struct list *l2);//输出链表void output(struct list *head);//输入链表void input(struct list *head,int num);int main(){ int n; list *h1,*h2; //两个链表的头，下面四行初始化链表 h1=(struct list*)malloc(sizeof(struct list)); h2=(struct list*)malloc(sizeof(struct list)); h1->next=NULL; h2->next=NULL; //两个链表输入 printf("请输入第一个链表节点数：\n"); scanf("%d",&n); input(h1,n); printf("请输入第二个链表节点数：\n"); scanf("%d",&n); input(h2,n); //合并链表并排序 sort(h1,h2); //输出合并后的链表 output(h1);}void input(struct list *head,int num){ struct list *tmp; struct list *end; end=head; printf("请输入链表节点：\n"); for(int i=0;i!=num;i++) { tmp=(struct list *)malloc(sizeof(struct list)); scanf("%d",&tmp->data); end->next=tmp; tmp->next=NULL; end=tmp; }}void sort(struct list *l1,struct list *l2){ struct list *p1,*p2,*tmp; p1=l1; p2=l2->next; while(p1->next&&p2) { if(p1->next->data>p2->data) { tmp=p2->next; p2->next=p1->next; p1->next=p2; p2=tmp; } else p1=p1->next; } if(p2) p1->next=p2;}void output(struct list *head){ while(head->next) { printf(" %d ",head->next->data); head=head->next; }}
ListNode*ReNewCombineList(ListNode*p1,ListNode*p2)//合并两个链表,,生成第三个链表递归
{
ListNode*pNewList=NULL;
//ListNode*p3=NULL;
if(p1==NULL)
return p2;
if(p2==NULL)
return p1;
if(p1->data
data)
{
pNewList=p1;
pNewList->next=ReNewCombineList(p1->next,p2);
}
else
{
pNewList=p2;
pNewList->next=ReNewCombineList(p1,p2->next);
}
return pNewList;
}
扩展资料：return
C++的关键字，它提供了终止函数执行的一种方式。当return语句提供了一个值时，这个值就成为函数的返回值.
说到return,有必要提及主函数的定义,下面是从网络上找到的资料,好好消化吧,对了解主函数中返回值的理解有很大的帮助.
很多人甚至市面上的一些书籍，都使用了void main()，其实这是错误的。C/C++中从来没有定义过void main()。
C++之父Bjarne Stroustrup在他的主页上的FAQ中明确地写着The definition void main(){/*...*/}is not and never has been C++,
nor has it even been C.（void main()从来就不存在于C++或者C）。下面我分别说一下C和C++标准中对main函数的定义。
1.C
在C89中，main()是可以接受的。Brian W.Kernighan和Dennis M.Ritchie的经典巨著The C programming Language 2e（《C程序设计语言第二版》）用的就是main()。不过在最新的C99标准中，只有以下两种定义方式是正确的：
int main(void)
int main(int argc,char*argv[])
（参考资料：ISO/IEC 9899:1999(E)Programming languages—C 5.1.2.2.1 Program startup）
当然，我们也可以做一点小小的改动。例如：char*argv[]可以写成char**argv；argv和argc可以改成别的变量名（如intval和charval），不过一定要符合变量的命名规则。
如果不需要从命令行中获取参数，请用int main(void)；否则请用int main(int argc,char*argv[])。
main函数的返回值类型必须是int，这样返回值才能传递给程序的激活者（如操作系统）。
如果main函数的最后没有写return语句的话，C99规定编译器要自动在生成的目标文件中（如exe文件）加入return 0;，表示程序正常退出。不过，我还是建议你最好在main函数的最后加上return语句，虽然没有这个必要，但这是一个好的习惯。
注意，vc6不会在目标文件中加入return 0;，大概是因为vc6是98年的产品，所以才不支持这个特性。现在明白我为什么建议你最好加上return语句了吧！不过，gcc3.2（Linux下的C编译器）会在生成的目标文件中加入return 0;。
求高手：C语言链表类上机题
1、*n 2、next 3、head
1.SLIST *creatlist(int *a);
根据指针a指向的大小为N的数组，创建单链表，并将头结点的指针作为返回值
2.void outlist(SLIST *);
outlist是个函数，不过此处是函数声明，函数的定义在main()函数之后
C语言 大一简单题目 链表 求解答
【正确答案】A
"互换"就是说，之前的链表为head——p——q——……，互换后变为head——q——p-——……
【注意】互换过程中原链表的结点信息不能丢！！！
->是结构体指针用来取起所指向结构体的分量（的值），指向结构体内的分量 ，例如：
p->key，就是取得的结构体内部的key；
具体操作：(顺序不能变！！！！否则链表信息容易丢失)
1、head->next=q;
2、p->next=q->next;
3、q->next=p
选项B、C、D都丢失了原链表中q以后的所有结点的信息，所以错误。
顺序表和链表的基本操作，用C语言实现！
你照下面的这个 去写。下面的这个是顺序表的基本操作，链表和这个差不多。
#include"1.h"
void main()
{
char a[5]={'a','b','c','d','e'};
int n=5;
char f='f',b='a',e;
SqList sq;
InitList(sq); //初始化表
CreateList(sq,a,n); //传入数据
DispList(sq); //输出表
printf("sq.length=%d\n",ListLength(sq)); //输出表长
if(ListEmpty(sq)) //判断是否为空表
printf("sq是空表\n");
else
printf("sq不是空表\n");
printf("a在第%d位\n",LocateElem(sq,b)); //按元素值查找
ListInsElem(sq,f,4); //在第4个位置上插入f元素
DispList(sq); //输出表
printf("\n");
DelElem(sq,3,e); //删除第三个元素
DispList(sq); //输出表
}
这是头文件
1.h
#include
const MaxSize=100;
typedef struct SqList
{
char elem[MaxSize];
int length;
}SqList,*PSqList;
SqList sq;
void InitList(SqList &sq) //初始化线性表
{
sq.length=0;
}
void CreateList(SqList &sq,char a[],int n) //建立表
{
int i;
for(i=0;i
<n;i++)
sq.elem[i]=a[i];
sq.length=n;
}
int ListLength(SqList sq) //求表长
{
return(sq.length);
}
char GetElem(SqList sq,int i) //求第i个元素
{
if(i<1||i>sq.length)
return 0;
return sq.elem[i-1];
}
int LocateElem(SqList sq,char x) //按元素值查找
{
int i=0;
while(i
<sq.length&&sq.elem[i]!=x)
i++;
if(i>sq.length)
return 0;
else return i+1;
}
int ListInsElem(SqList &sq,char x,int i) //插入元素在第i个位置
{
int j;
if(i<1||i>sq.length+1)return 0;
for(j=sq.length;j>=i;j--)
sq.elem[j]=sq.elem[j-1];
sq.elem[i-1]=x;
sq.length++;
return 1;
}
int DelElem(SqList &sq,int i,char &e) //删除第i个元素
{
int j;
if (i<1||i>sq.length)return 0;
e=sq.elem[i];
for(j=i;j
<sq.length;j++)
sq.elem[j-1]=sq.elem[j];
sq.length--;
return 1;
}
int ListEmpty(SqList &sq) //判断表是否为空
{
return(sq.length==0);
}
void DispList(SqList sq) //输出表
{
int i;
if(ListEmpty(sq))return;
for(i=0;i
<sq.length;i++)
printf("%c\t",sq.elem[i]);
}
顺序存储的线性表的算法
#include "stdio.h"
#include "stdlib.h"
#define Status int
#define OVERFLOW 0
#define TRUE 1
#define FALSE 0
#define OK 1
#define MAXSIZE 100
typedef int ElemType;
typedef struct list
{ElemType elem[MAXSIZE];
int length;
}SqList;
void InitList(SqList &L){
L.length=0;
}
/*建立顺序表*/
void CreateList(SqList &L)
{
int i;
printf("input the length");
scanf("%d",&L.length);//输入表长
for(i=1;i<=L.length;i++)
scanf("%d",&L.elem[i-1]);//输入元素
}
//顺序表的遍历
void printdata(ElemType e){
printf("%4d",e);
}
void Traverse(SqList L,void (*visit)(ElemType e))
{ int i;
printf("The elements of the lists are:\n");
for(i=1;i<=L.length;i++){
if (i%10==0)printf("\n");//每行显示10个元素
visit(L.elem[i-1]);//输出表中元素
}
printf("\n");
}
//有序顺序表L中插入元素e使序列仍有序
void Insert(SqList &L,ElemType e)
{int i,j;
if (L.length==MAXSIZE)exit(OVERFLOW);//表满,不能插入
for(i=1;i<=L.length&&L.elem[i-1]<=e;i++);//向后查找
for(j=L.length;j>=i;j--)
L.elem[j]=L.elem[j-1];//元素后移
L.elem[i-1]=e;//插入e
L.length=L.length+1;//表长加1
}
//建立递增有序的顺序表
void CreateList_Sorted(SqList &L)
{int i,num;
ElemType e;
L.length=0;
printf("Create a sorted list,Input the length of the list\n");
scanf("%d",&num);
printf("Input the data %d numbers\n",num);
for(i=1;i<=num;i++){
scanf("%d",&e);
Insert(L,e);
}
}
/*Merge two sorted lists*/
void MergeList(SqList La,SqList Lb,SqList &Lc)
{int *pa,*pb,*pc;
if (La.length+Lb.length>MAXSIZE) exit(OVERFLOW);
else
{pa=La.elem;pb=Lb.elem;pc=Lc.elem;
while (pa
<la.elem+la.length&&pb<lb.elem+lb.length)
*pc++=(*pa<=*pb)?*pa++:*pb++;/*公共部分合并*/
while (pa
<la.elem+la.length) *pc++="*pa++;
/*R1表的剩余部分放到R的后部*/
while (pb
<lb.elem+lb.length) *pc++="*pb++;
/*R2表的剩余部分放到R的后部*/
Lc.length=La.length+Lb.length;/*R表长*/
}
}
//判断元素是否对称，对称返回TRUE 否则返回FALSE
Status Symmetric(SqList L)
{int low,high;
low=0;
high=L.length-1;
while(low
<high)
if (L.elem[low]==L.elem[high]){low++;high--;}
else return(FALSE); return(TRUE); }
//顺序表的主函数部分
//#include "seqlist.h"
void main()
{SqList L1,L2,L;
int select;
ElemType e;
do{printf("\n1 insert 2 merge");
printf("\n3 symmetric 0 exit \n");
printf("Please select(0--3)\n");
scanf("%d",&select);
switch(select){
case 1:
InitList(L);
CreateList_Sorted(L);
Traverse(L,printdata);
printf("\nInput the element of inserted\n");
scanf("%d",&e);
Insert(L,e);
Traverse(L,printdata);
break;
case 2:
InitList(L1);
CreateList_Sorted(L1);
Traverse(L1,printdata);
InitList(L2);
CreateList_Sorted(L2);
Traverse(L2,printdata);
InitList(L);
MergeList(L1,L2,L);
Traverse(L,printdata);
break;
case 3:
InitList(L);
CreateList(L);
Traverse(L,printdata);
if (Symmetric(L)) printf("Yes!\n"); else printf("Not\n");
break;
case 0:break;
default:printf("Error! Try again!\n");
}
}while(select);
}
/*单向链表的有关操作示例*/
/*类型定义及头文件部分,文件名为sllink.h*/
#include
#include
typedef int ElemType;//元素实际类型
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList; //定义结点、指针类型名
//头插法建立无序链表
void CreateList(LinkList &L){
LinkList p;
ElemType e;
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
printf("头插法建立链表，以0结束\n");
scanf("%d",&e);
while(e){
p=(LinkList)malloc(sizeof(LNode));
p->data=e;
p->next=L->next;
L->next=p;
scanf("%d",&e);
}
}
/*非递减有序单向链表L插入元素e序列仍有序*/
void Insert_Sort(LinkList &L,ElemType e){
LinkList p,s;
s=(LinkList)malloc(sizeof(LNode));
s->data=e;
p=L;
while(p->next&&p->next->data<=e)
p=p->next;/*查找插入位置*/
s->next=p->next; /*插入语句*p结点后插入*s结点*/
p->next=s;
}
/*建立递增有序的单向链表*/
void Create_Sort(LinkList &L){
ElemType e;
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
printf("建立有序表，输入任意个整型数据以0结束\n");
scanf("%d",&e);
while(e){
Insert_Sort(L,e);
scanf("%d",&e);
}
}
/*单向链表的遍历*/
void Traverse(LinkList L){
LinkList p;
printf("遍历链表");
for(p=L->next;p;p=p->next)
printf("%5d",p->data);
printf("\n");
}
/*在单向链表删除元素e*/
void Delete(LinkList &L,ElemType e){
LinkList p,q;
p=L;
q=L->next;
while(q&& q->data!=e){//查找元素的删除位置
p=q;
q=q->next;
}
if(!q) printf("\nnot deleted");/*未找到元素e*/
else {p->next=q->next;/*找到删除*/
free(q);}
}
/*单向链表的逆置*/
void exch(LinkList &L){
LinkList p,s;
p=L->next;
L->next=NULL;
while(p){
s=p;
p=p->next;
s->next=L->next;
L->next=s;
}
}
/*两个非递减有序单向链表合并后仍为非递减序列*/
void MergeIncrease(LinkList La,LinkList Lb,LinkList &Lc){
LinkList p,q,s,rear;
p=La->next;
q=Lb->next;
Lc=rear=La;
free(Lb);
while(p&&q){
if (p->data
data) {s=p;p=p->next; }
else {s=q;q=q->next; }
rear->next=s;/*较小元素插入表尾*/
rear=rear->next;
}
if (p) rear->next=p; else rear->next=q;
}
/*主函数部分,文件名为sllink.c*/
//#include "sllink.h"
void main(){
LinkList La,Lb,Lc;
ElemType e;
int select;
do{
printf(" 1 建立无序表，再删除指定元素\n");
printf(" 2 建立递增有序表，再逆置\n");
printf(" 3 建立两个递增有序表，将它们和并为一个仍递增表\n");
printf(" 0 退出，请输入选项(0-3)\n");
scanf("%d",&select);
switch(select){
case 0:
break;
case 1:
CreateList(La);
Traverse(La);
printf("输入需删除的元素\n");
scanf("%d",&e);
Delete(La,e);
Traverse(La);
break;
case 2:
Create_Sort(La);
Traverse(La);
exch(La);
printf("The list that is exchaged\n");
Traverse(La);
break;
case 3:
Create_Sort(La);Traverse(La);
Create_Sort(Lb);Traverse(Lb);
MergeIncrease(La,Lb,Lc);Traverse(Lc);
break;
default:
printf("输入选项错误，请重新输入！\n");
}
}while(select);
}
这些内容不知道能不能帮助到你。
</high)
</la.elem+la.length&&pb<lb.elem+lb.length)
</sq.length;i++)
</sq.length;j++)
</sq.length&&sq.elem[i]!=x)
</n;i++)