‘壹’ 编写一个c语言程序 实现单链表的基本操作
# include <stdio.h>
# include <malloc.h>
# include <stdlib.h>
typedef struct Node
{
int data;
struct Node * pNext;
} * PNODE, NODE;
PNODE establish_list (void);
void traverse_list (PNODE pHead);
bool is_empty(PNODE pHead);
int length_list(PNODE pHead);
void sort_list(PNODE pHead);
void insert_list(PNODE pHead, int pos, int val);
int delete_list(PNODE pHead, int pos, int val);
void freeer(PNODE pHead);
int main(void)
{
PNODE pHead;
int len, i, j, val;
pHead = establish_list();
traverse_list(pHead);
if(is_empty(pHead))
printf("链表为空\n");
else
printf("链表不空\n");
len = length_list(pHead);
printf("链表的长度为: %d\n", len);
sort_list(pHead);
traverse_list(pHead);
printf("请输入您要在第几个节点插入\n");
scanf("%d", &i);
printf("请输入您要在第%d个节点插入的值\n", i);
scanf("%d", &j);
insert_list(pHead, i, j);
traverse_list(pHead);
printf("请输入您要第几个删除的节点\n");
scanf("%d", &i);
val = delete_list(pHead, i, val);
printf("您删除的节点值为: %d\n", val);
traverse_list(pHead);
freeer(pHead);
return 0;
}
PNODE establish_list(void)//初始化链表，返回头结点地址
{
int val, len;
PNODE Tem;
PNODE pNew;
PNODE pHead;
pHead = (PNODE)malloc(sizeof(NODE));
Tem = pHead;
if(NULL == pHead)
{
printf("分配失败");
exit(-1);
}
Tem->pNext = NULL;
printf("请输入您要定义节点的长度: ");
scanf("%d", &len);
for (int i=0;i<len;++i)
{
printf("请输入第%d个节点的值: ", i+1);
scanf("%d", &val);
pNew = (PNODE)malloc(sizeof(NODE));
if(NULL == pNew)
{
printf("分配失败");
exit(-1);
}
pNew->data = val;//首先把本次创建的新节点的值付给新节点的数据域
Tem->pNext = pNew;//然后使用临时的节点变量的指针域保存了新节点的地址，也就是指向了新节点
pNew->pNext = NULL;//如何再不循环，新节点成为最后一个节点
Tem = pNew;//把本次分配的新节点完全的赋给Tem，Tem就成为了这次新节点的影子,那么下次分配新节点时可以使用上个新节点的数据
}
return pHead;
}
void traverse_list(PNODE pHead)
{
PNODE p = pHead;//使用P是为了不改写头结点里保存的地址
p = pHead->pNext;//使P指向首节点
while(p != NULL)//P本来就是头结点的指针域，也就是首节点的地址，既然是地址就可以直接判断p是否等于NULL
{
printf("%d ", p->data);
p = p->pNext;//使P每循环一次就变成P的下一个节点
}
}
bool is_empty(PNODE pHead)
{
if(NULL == pHead->pNext)
return true;
else
return false;
}
int length_list(PNODE pHead)
{
PNODE p = pHead->pNext;
int len = 0;
while(p != NULL)
{
len++;
p = p->pNext;
}
return len;
}
void sort_list(PNODE pHead)
{
int i, j, t, len;
PNODE p, q;
len = length_list(pHead);
for(i=0,p=pHead->pNext;i<len;i++,p=p->pNext)//逗号后只是为了找到下一个节点，因为不是数组，所以不能使用下标来++
{
for(j=0,q=pHead->pNext;j<len;j++,q=q->pNext)
if(q->data > p->data)//这里的大小与号可以决定是升序还是降序，如果是大于号就是升序,反之小于号就是降序
{
t = q->data;
q->data = p->data;
p->data = t;
}
}
return;
}
void insert_list(PNODE pHead, int pos, int val)
{
int i;
PNODE q = pHead;
PNODE p = pHead;
if(pos > 0 && pos <= length_list(pHead))
{
for(i=0;i<pos;i++)
{
q = q->pNext;//q就是要插入的连接点
}
for(i=1;i<pos;i++)
{
p = p->pNext;//p就是要插入连接点的前一个节点
}
PNODE pNew = (PNODE)malloc(sizeof(NODE));
p->pNext = pNew;
pNew->data = val;
pNew->pNext = q;
}
else if(pos > length_list(pHead))//追加
{
PNODE t;
t = pHead;
PNODE PN;
PN = (PNODE)malloc(sizeof(NODE));
if(PN == NULL)
printf("分配失败");
else
while(t->pNext != NULL)
{
t = t->pNext;//使T->pNext成为尾结点
}
PN->data = val;//给新节点赋予有效数据
t->pNext = PN;//使尾结点的指针域指向了新的结点
PN->pNext = NULL;//新节点成为尾结点
}
else
printf("error\n");
return;
}
int delete_list(PNODE pHead, int pos, int val)
{
int i, j;
PNODE q, p;
q = pHead;
p = pHead;
if(pos > 0 && pos <= length_list(pHead))//保证删除的是节点的有效数
{
for(i=0;i<pos;i++)
{
p = p->pNext;
}
for(j=1;j<pos;j++)
{
if(pos == 0)
q = pHead;
else
q = q->pNext;
}
q->pNext = p->pNext;
val = p->data;
free(p);
return val;
}
else
printf("error");
}
void freeer(PNODE pHead)
{
PNODE pT = pHead;
while(NULL != pHead->pNext)
{
free(pT);
pT = pT->pNext;
}
return;
}
/*
好久以前写的一个链表了，有排序，插入，删除，输出，判断是否为空，甚至还有释放堆中内存的功能
*/
‘贰’ C语言全套教学视频
C语言程序设计
若资源有问题欢迎追问~
‘叁’ 求数据结构单链表C语言视频教程
网络搜 清华严蔚敏数据结构视频教程
就在前几个视频里面
‘肆’ 用C语言实现对单链表的基本操作
#include<stdio.h>
#include<stdlib.h>
typedefintDataType;
typedefstructnode{
DataTypemember;
structnode*next;
}*LinkList,*pNode;
//初始化链表
LinkListGetEmptyList(){
LinkListhead=(pNode)malloc(sizeof(structnode));
head->member=0;
head->next=NULL;
returnhead;
}
//在非增链表中插入结点
voidInsertNode(LinkListhead,DataTypex){
pNodep,q;
for(p=head;p->next!=NULL;p=p->next){
if(p->next->member<=x){
q=(pNode)malloc(sizeof(structnode));
q->member=x;
q->next=p->next;
p->next=q;
return;
}
}
q=(pNode)malloc(sizeof(structnode));
q->member=x;
q->next=p->next;
p->next=q;
}
//新结点插入为首结点
voidPushNode(LinkListhead,DataTypex){
pNodep=(pNode)malloc(sizeof(structnode));
p->member=x;
p->next=head->next;
head->next=p;
}
//删除结点
intDeleteNode(LinkListhead,DataTypex){
pNodep,q;
for(p=head;p!=NULL;p=p->next){
if(p->next->member==x){
q=p->next;
p->next=q->next;
free(q);
return1;//成功删除member(第一个)为x的结点
}
}
return0;//没有找到member为x的结点
}
//查找结点
intFindNode(LinkListhead,DataTypex){
pNodep;
for(p=head->next;p!=NULL;p=p->next){
if(p->member==x)return1;//找到了
}
return0;//没有找到
}
//销毁链表
voidDestroyList(LinkListhead){
pNodeq,p=head;
while(p){
q=p;
p=q->next;
free(q);
}
head=NULL;
}
//遍历链表
voidShowList(LinkListhead){
pNodep=head->next;
while(p!=NULL){
printf("%d",p->member);
p=p->next;
}
printf(" ");
}
intmain(){
DataTypex,res;
LinkListhead=GetEmptyList();
printf("输入一个整数('q'toquit):");
while(scanf("%d",&x)==1){
InsertNode(head,x);//创建非增链表
printf("输入一个整数('q'toquit):");
}
fflush(stdin);
ShowList(head);
printf("输入待查找的整数:");
scanf("%d",&x);
res=FindNode(head,x);
if(res)printf("找到了。 ");
elseprintf("没找到！ ");
printf("输入待删除的整数:");
scanf("%d",&x);
res=DeleteNode(head,x);
if(res)printf("成功删除。 ");
elseprintf("没找到数据为:%d的结点！ ",x);
ShowList(head);
DestroyList(head);
return0;
}
‘伍’ C语言，单链表
#include <stdio.h>
#include <stdlib.h>
#define ERROR 0
#define OK 1
typedef struct LNode{ //定于链表
int data;
struct LNode *next;
}Lnode,*LinkList;
LinkList initlist(LinkList L) //创建链表，创建头结点
{
L=(LinkList)malloc(sizeof(Lnode));
L->next=NULL;
return L;
}
void creatlist(LinkList L) //初始化链表
{
LinkList p=L,s;
int e;
printf("please enter the numbers and -1 to end:\n");
scanf("%d",&e);
while(e!=-1) //输入-1结束
{
scanf("%d",&e);
s=(LinkList)malloc(sizeof(Lnode));
s->data=e;
p->next=s;
p=s;
}
p->next=NULL;
}
void insertelem(LinkList L,int e) //在单链表中增添e
{
LinkList p=L,s;
while(p->next&&p->next->data<e)
p=p->next;
if(!p->next||p->next->data>e)
{
s=(LinkList)malloc(sizeof(Lnode));
s->data=e;
s->next=p->next;
p->next=s;
}
}
int deletelem(LinkList L,int e) //在单链表中删除e
{
LinkList p=L,q;
while(p->next&&p->next->data<e)
p=p->next;
if(!p->next||p->next->data>e)
return ERROR;
q=p->next;
p->next=q->next;
free(q);
return OK;
}
void printlist(LinkList L) //输出链表中所有元素
{
LinkList p=L->next;
while(p)
{
printf("%d ",p->data);
p=p->next;
}
printf("\n");
}
int main(void)
{
LinkList l=NULL;
int i,e;
l=initlist(l);
creatlist(l);
printlist(l);
printf("please enter the number you want to insert:\n");
scanf("%d",&e);
insertelem(l,e);
printf("the list after insert element is:\n");
printlist(l);
printf("please enter the number you want to delet:\n");
scanf("%d",&e);
if(deletelem(l,e))
{
printf("the list after delete is:\n");
printlist(l);
}
else
printf("the element doexn't exit\n");
return 0;
}
‘陆’ C语言实现单链表问题
//童鞋，你的表头没了。。。其他的函数我不看了，这个是链表尾插法的建立与输出，你仔细看到底哪里错了，有很多语法错误，如有不懂留言
#include <stdio.h>
#include <stdlib.h>
typedef int Type;
typedef struct SS
{
int Element;
struct SS *Next;
}Node;
void Print_List(Node *head);
void Insert(Type I_Element,Node *head);
void Insert(Type I_Element,Node *head)
{
Node *L = NULL;
Node *p = NULL;
L = head;
while (L->Next != NULL)
{
L = L->Next;
}
p = (Node *) malloc (sizeof(Node));
if(p == NULL)
{
printf("Out of memory!!!");
exit(0);
}
else
{
p->Element = I_Element;
p->Next = NULL;//
L->Next = p;
}
}
void Print_List(Node *head)
{
Node *p = head->Next;
while(p != NULL)
{
printf("%d", p->Element);
p = p->Next;
}
printf("\n");
}
int main()
{
int i;
Node *head = (Node *)malloc(sizeof(Node));
if (NULL == head)
{
exit(0);
}
head->Next = NULL;//建立空表头
for (i=0; i<10; i++)
{
Insert(i, head);
}
Print_List(head);
}
‘柒’ c语言单向链表
name 保存在结构体单元的name[20] 数组里;
typedef struct node
{
char name[20];
struct node *link;
}stud;
这是你前面定义的结构体变量，一个单元包含两个部分，一个用来存储name的数组name[20],一个用来存放下一个单元地址的指向结构体node的指针。
假设该单元的地址是p,那么p->name 表示第一部分name[20]的地址，p->link表示第二部分，作用是存放下一个单元的地址。
--------------》你看不懂的部分如下《-----------------
p->link=s; /*把s的地址赋给p所指向的结点的链域，这样就把p和s所指向的结点连接起来了*/
printf("请输入第%d个人的姓名",i+1);
scanf("%s",s->name); /*在当前结点s的数据域中存储姓名*/
s->link=NULL;
p=s;
}
在这段代码前面是分配一个结构体单元空间，s是这个新分配空间的地址，p是链表的尾节点的地址，以链表形式说，新分配的应当跟在它后面。
按上面所讲，p->link用来存放下一单元的地址，因此有：
p->link=s; 这样新节点就成为链表的一部分了。
printf("请输入第%d个人的姓名",i+1);
scanf("%s",s->name);
这两句，是对将需要输入的名字读入并且存放在新节点用于存放name 的数组中。
此时，刚开辟的新节点成了尾节点，尾节点不指向任何其它节点，因此s->link=NULL;（NULL是空指针）
（C中处理指针需要小心行事）
p=s; 将p变量赋值为s,即让其为尾节点的地址，便于继续添加节点。
‘捌’ c语言用单链表基本操作实现
补充销毁链表、打印链表内容的两个函数。主函数已补上建立、插入、删除、打印诸代码。
#include<stdio.h>
#include<stdlib.h>
#include<stdlib.h>
typedefintElemType;
typedefstructNode{
ElemTypedata;
structNode*next;
}LNode,*LinkList;
voidinilialist(LNode**L){
if((*L=(LNode*)malloc(sizeof(LNode)))==NULL)
exit(1);
(*L)->next=NULL;
}
/*销毁*/
/*初始条件：单链表L已存在。操作结果：销毁单链表L*/
voiddestroyList(LinkListL){
LinkListp,q;
p=L->next;/*p指向第一个结点*/
while(p){/*没到表尾*/
q=p->next;
free(p);
p=q;
}
free(L);
}
voidinsert(LNode*L,inti,ElemTypex){
LNode*s,*p=L;
intj=0;
while(j!=(i-1)&&p!=NULL){
p=p->next;
j++;
}
if(p==NULL){
printf("序号出错！");
}
else{
if((s=(LNode*)malloc(sizeof(LNode)))==NULL)
exit(1);
s->data=x;
s->next=p->next;
p->next=s;
}
}
voidDelete(LNode*L,inti){//删除值为x的结点
LNode*p;
LNode*u;
intj=0;
p=L;
while(j!=i-1&&p!=NULL){
p=p->next;
j++;
}
if(p==NULL||p->next==NULL){
printf("删除序号出错！");
}
else{
u=p->next;
p->next=u->next;
free(u);
}
}
/*打印链表内容*/
/*初始条件：单链表L已存在。操作结果：当链表不为空时，打印链表内容并返回OK，否则返回ERROR*/
intprintList(LinkListL){
LinkListp=L->next;/*p指向第一个结点*/
while(p){
printf("%d ",p->data);
p=p->next;
}
putchar(' ');
return1;
}
intmain(void){
LinkListL;
inti;
/*初始化单链表*/
inilialist(&L);
/*插入10个元素*/
printf("建立10个数据元素的线性表： ");
for(i=1;i<=10;i++)
insert(L,i,i);
printList(L);
putchar(' ');
puts("第2位置插入元素25：");
insert(L,2,25);
printList(L);
putchar(' ');
puts("删除第4个位置上的元素：");
Delete(L,4);
printList(L);
putchar(' ');
destroyList(L);
getch();/*屏幕暂留*/
return0;
}
‘玖’ C语言头插法建立单链表
1. 所谓头指针即为指向链表第一个节点的指针(若链表含有头结点,则指向头结点),该指针变量的值即为链表第一个节点(或头节点)的地址 ,故对于你这段代码来说头指针L存放的是链表第一个元素的地址(因为没有头节点),若要将s所指向的元素要插入到表头,步骤如下:(1)新元素与链表建立连接,(2)断开头指针与链表的连接,(3)头指针指向新的表头(本程序中即s所指的元素).
用代码实现即为:(1)s->next=L(L原先指向第一个元素,现在让新元素与链表建立连接,新元素成为表头元素,原来的表头元素成为链表上的第二个元素,需要将s的链接指针指向原先的表头元素,即把L中原先存储的表头元素的地址赋给s的next指针),(2)(3)L=s(第一步完成了新元素加入链表的操作,若要想新元素作为链表的第一个元素,就要把它的地址赋给头指针L,因为L作为头指针应该始终指向表头元素.这个语句就是实现第二和第三步的:断开头指针与链表的连接,头指针指向新的表头)
2. 如果你对上面的解释能接受的话,那么这一问你应该可以解答了:分析过程就不写了,由头至尾为:5->4->3->2->1
3. 至于这一问,要放到具体的上下文环境中来解释,但无非就是链表的插入,删除操作.可以找相关的资料看一看
诚如一楼所言:这部分刚开始学习时最好画个图,就很容易明白了
你也可以去这看一看:
http://blog.csdn.net/bingwen0210/archive/2007/04/07/1556089.aspx
上面有图.