c语言输入一个链表,如何用c语言创建链表和输入一个新链表

最新推荐文章于 2023-01-02 18:02:27 发布
最新推荐文章于 2023-01-02 18:02:27 发布
阅读量130 收藏
点赞数
文章标签： c语言输入一个链表

#include "stdlib。h"

#include "stdio。h"

struct listNode{

int data;

struct listNode *nextPtr;

};

typedef struct listNode LISTNODE;

typedef LISTNODE * LISTNODEPTR;

/*LISTNODEPTR£ºÖ¸ÏòLISTNODEÖ¸Õë*/

LISTNODE * createFIFOList1();

LISTNODEPTR createFILOList();

void createFIFOList2(LISTNODEPTR *);

void printList(LISTNODEPTR );

void destroyList(LISTNODEPTR);

LISTNODEPTR find(LISTNODEPTR currentPtr, int value);

void insertNode(LISTNODEPTR *sPtr,int value);

LISTNODEPTR createSortList();

int deleteNode(LISTNODEPTR *sPtr, int value);

void printListR(LISTNODEPTR currentPtr);

void printListS(LISTNODEPTR currentPtr);

LISTNODEPTR findMax(LISTNODEPTR headPtr);

LISTNODEPTR findMaxR(LISTNODEPTR headPtr);

LISTNODEPTR reverseList(LISTNODEPTR headPtr);

LISTNODEPTR reverseList2(LISTNODEPTR headPtr);

LISTNODEPTR reverseList3(LISTNODEPTR headPtr);

void findPos(LISTNODEPTR headPtr,int value,LISTNODEPTR * previousPtr,LISTNODEPTR * currentPtr);

LISTNODEPTR mergeSortList(LISTNODEPTR head1Ptr,LISTNODEPTR head2Ptr);

main()

{

LISTNODEPTR headPTR = NULL;

int data;

LISTNODEPTR point;

int type;

int result;

// headPTR = createFIFOList1();

// createFIFOList2(&headPTR);

// printList(headPTR);

headPTR = createSortList();

printList(headPTR);

/*

printf("ÇëÊäÈëÒª·þÎñµÄÖÖÀࣺ0, ´òÓ¡£¬1 ²éÕÒ£¬2 ²åÈ룬3 ɾ³ý£¬4 ÄæÐò´òÓ¡, 5 ÕÒ×î´óÊý, 6 ÄæתÁ´±í£¬7 Á´±í¹é²¢£¬-1½áÊø£º

");

scanf("%d", &type);

while(type != -1)

{

switch(type)

{

case 0:

{

printListS(headPTR);

break;

}

case 4:

{

printListR(headPTR);

break;

}

case 1:

{

printf("ÇëÊäÈëÒª²éÕÒµÄÊý¾Ý£º");

scanf("%d", &data);

if(point = find(headPTR, data))

printf("%d

", point->data);

else

printf("ûÓÐÕÒµ½

");

break;

}

case 2:

{

printf("ÇëÊäÈëÒª²åÈëµÄÊý¾Ý£º");

scanf("%d", &data);

insertNode(&headPTR, data);

break;

}

case 3:

{

printf("ÇëÊäÈëҪɾ³ýµÄÊý¾Ý£º");

scanf("%d", &data);

result = deleteNode(&headPTR, data);

printf("ɾ³ýµÄ½á¹ûΪ£º%d

", result);

break;

}

case 5:

{

LISTNODEPTR resultPtr = findMax(headPTR);

printf("×î´óֵΪ£º%d

", resultPtr->data);

break;

}

case 6:

{

LISTNODEPTR resultPtr = reverseList2(headPTR);

printListS(resultPtr);

break;

}

case 7:

{

LISTNODEPTR headPtr2 = createSortList();

printList(headPtr2);

headPTR = mergeSortList(headPTR, headPtr2);

printList(headPTR);

break;

}

}

printf("

ÇëÊäÈëÒª·þÎñµÄÖÖÀࣺ0, ´òÓ¡£¬1 ²éÕÒ£¬2 ²åÈ룬3ɾ³ý£¬4ÄæÐò´òÓ¡£¬5 ÕÒ×î´óÊý£¬6 ÄæתÁ´±í£¬7 Á´±í¹é²¢£¬ -1½áÊø£º

");

scanf("%d", &type);

}

destroyList(headPTR);

*/

system("pause");

}

LISTNODE * createFIFOList1()

{

int num;

LISTNODEPTR headPtr=NULL,lastPtr=NULL,currentPtr=NULL;

printf("input positive numbers,-1 to end

");

scanf("%d",&num);

while(num!=-1)

{

currentPtr=malloc(sizeof(LISTNODE)); /*·ÖÅä½áµãÄÚ´æ*/

if(currentPtr!=NULL)

{/*²åÈë½áµã*/

currentPtr->data=num;

currentPtr->nextPtr = NULL;

if(headPtr==NULL)

{ /*ÈôcurrentPtrÊÇÍ·½áµã*/

headPtr=currentPtr;

lastPtr=currentPtr;

}

else

{

lastPtr->nextPtr=currentPtr; /*½«½áµãÁ¬ÉÏÁ´±íβ½áµã*/

lastPtr=currentPtr; /*ʹlastPtrÖ¸Ïòµ±Ç°Á´±íµÄ×îºóÒ»¸ö½áµã*/

}

}

scanf("%d",&num);

}

// lastPtr->nextPtr=NULL;/*ÉèÖÃÁ´±í½áÊø±ê¼Ç*/

return headPtr;

}

void createFIFOList2(LISTNODEPTR *sPTR)

{

int num;

LISTNODEPTR headPtr=NULL,lastPtr=NULL,currentPtr=NULL;

printf("input positive numbers,-1 to end

");

scanf("%d",&num);

while(num!=-1)

{

currentPtr=malloc(sizeof(LISTNODE)); /*·ÖÅä½áµãÄÚ´æ*/

if(currentPtr!=NULL)

{/*²åÈë½áµã*/

currentPtr->data=num;

if(headPtr==NULL)

{ /*ÈôcurrentPtrÊÇÍ·½áµã*/

headPtr=currentPtr;

lastPtr=currentPtr;

}

else

{

lastPtr->nextPtr=currentPtr; /*½«½áµãÁ¬ÉÏÁ´±íβ½áµã*/

lastPtr=currentPtr; /*ʹlastPtrÖ¸Ïòµ±Ç°Á´±íµÄ×îºóÒ»¸ö½áµã*/

}

}

scanf("%d",&num);

}

lastPtr->nextPtr=NULL;/*ÉèÖÃÁ´±í½áÊø±ê¼Ç*/

*sPTR = headPtr;

}

LISTNODEPTR createFILOList()

{

LISTNODEPTR headPTR, currentPTR;

int num;

headPTR = NULL;

currentPTR = NULL;

printf("input positive numbers,-1 to end

");

scanf("%d",&num);

while(num!=-1)

{

currentPTR = (LISTNODEPTR)malloc(sizeof(LISTNODE));

if(currentPTR != NULL)

{

currentPTR->data = num;

if(headPTR == NULL)

{

headPTR = currentPTR;

headPTR->nextPtr = NULL;

}

else

{

currentPTR->nextPtr = headPTR;

headPTR = currentPTR;

}

}

scanf("%d", &num);

}

return headPTR;

}

void printList(LISTNODEPTR currentPtr)

{

if(currentPtr==NULL)

printf("the list is empty

");

else

{

printf("the list is:

");

while(currentPtr!=NULL)

{

printf("%d-->",currentPtr->data);

currentPtr=currentPtr->nextPtr;

}

printf("NULL

");

}

}

void destroyList(LISTNODEPTR headPtr)

{

LISTNODEPTR tempPtr;

while(headPtr!=NULL)

{

tempPtr=headPtr;

headPtr=headPtr->nextPtr;/*headPtrÖ¸ÏòÏÂÒ»¸öÒª ɾ³ýµÄ½áµã*/

free(tempPtr);

}

}

LISTNODEPTR find(LISTNODEPTR currentPtr, int value)

{

while(currentPtr != NULL && currentPtr->data != value)

{

currentPtr = currentPtr->nextPtr;

}

return currentPtr;

}

void insertNode(LISTNODEPTR *sPtr,int value)

{

LISTNODEPTR newPtr, previousPtr, currentPtr;

newPtr = (LISTNODEPTR)malloc(sizeof(LISTNODE));

if(newPtr != NULL)

{

newPtr->data = value;

newPtr->nextPtr = NULL;

previousPtr = NULL;

currentPtr = *sPtr;

while(currentPtr != NULL && currentPtr->data nextPtr;

}

if(currentPtr == *sPtr)

{

*sPtr = newPtr;

newPtr->nextPtr = currentPtr;

}

else if(currentPtr == NULL)

{

previousPtr->nextPtr = newPtr;

}

else

{

previousPtr->nextPtr = newPtr;

newPtr->nextPtr = currentPtr;

}

}

}

LISTNODEPTR createSortList()

{

int num;

LISTNODEPTR headPtr = NULL;

printf("ÇëÊäÈëÕûÊýÒÔ-1Ϊ½áÊø£º

");

scanf("%d", &num);

while(num != -1)

{

insertNode(&headPtr, num);

scanf("%d", &num);

}

return headPtr;

}

int deleteNode(LISTNODEPTR *sPtr, int value)

{

LISTNODEPTR previousPtr, currentPtr;

previousPtr = NULL;

currentPtr = *sPtr;

while(currentPtr != NULL && currentPtr->data != value)

{

previousPtr = currentPtr;

currentPtr = currentPtr->nextPtr;

}

if(currentPtr != NULL)

{

if(previousPtr == NULL)

{

*sPtr = currentPtr->nextPtr;

}

else

previousPtr->nextPtr = currentPtr->nextPtr;

free(currentPtr);

return value;

}

else

return -1;

}

void printListS(LISTNODEPTR currentPtr)

{

if(currentPtr->nextPtr == NULL)

printf("%d->", currentPtr->data);

else

{

printf("%d->", currentPtr->data);

printListS(currentPtr->nextPtr);

}

}

void printListR(LISTNODEPTR currentPtr)

{

if(currentPtr->nextPtr == NULL)

printf("%d->", currentPtr->data);

else

{

printListR(currentPtr->nextPtr);

printf("%d->", currentPtr->data);

}

}

LISTNODEPTR findMax(LISTNODEPTR headPtr)

{

LISTNODEPTR maxPtr, currentPtr;

maxPtr = headPtr;

currentPtr = headPtr->nextPtr;

while(currentPtr)

{

if(currentPtr->data > maxPtr->data)

{

maxPtr = currentPtr;

}

currentPtr = currentPtr->nextPtr;

}

return maxPtr;

}

LISTNODEPTR findMaxR(LISTNODEPTR headPtr)

{

LISTNODEPTR maxPtr;

if(headPtr->nextPtr == NULL)

return headPtr;

else

{

maxPtr = findMaxR(headPtr->nextPtr);

return headPtr->data>maxPtr->data?headPtr:maxPtr;

}

}

LISTNODEPTR reverseList(LISTNODEPTR headPtr)

{

LISTNODEPTR newHeadPtr, currentPtr;

newHeadPtr = NULL;

currentPtr = NULL;

while(headPtr)

{

currentPtr = headPtr;

headPtr = currentPtr->nextPtr;

if(newHeadPtr == NULL)

{

newHeadPtr = currentPtr;

currentPtr->nextPtr = NULL;

}

else

{

currentPtr->nextPtr = newHeadPtr;

newHeadPtr = currentPtr;

}

}

return newHeadPtr;

}

LISTNODEPTR reverseList2(LISTNODEPTR headPtr)

{

LISTNODEPTR previousPtr, currentPtr, nextPtr;

previousPtr = NULL;

currentPtr = headPtr;

while(currentPtr != NULL)

{

nextPtr = currentPtr->nextPtr;

currentPtr->nextPtr = previousPtr;

previousPtr = currentPtr;

currentPtr = nextPtr;

}

return previousPtr;

}

LISTNODEPTR reverseList3(LISTNODEPTR headPtr)

{

LISTNODEPTR lastPtr=NULL,currentPtr=NULL;

if(headPtr->nextPtr==NULL){//ÈôÊÇ×îºóÒ»¸ö½áµã£¬ÔòÖ±½Ó·µ»Ø

return headPtr;

}

else{

/*1。

µ±Ç°Á´±íÍ·½áµã´ÓÁ´±íÖвð³ý£¬ÓÉlastPtrÖ¸Ïò£¬½«³ÉΪÄæÐòºóµÄÁ´±íβ½áµã¡£headPtrÖ¸ÏòÏÂÒ»½áµã*/

lastPtr=headPtr;

headPtr=headPtr->nextPtr;

lastPtr->nextPtr=NULL;

/*2。

µÝ¹éµ÷Ó㬽«headPtrÖ¸ÏòµÄÁ´±íÄæÐò£¬ÓÉnewHeadPtrÖ¸Ïò */

headPtr=reverseList(headPtr);

/*3。 ½«lastPtrÖ¸Ïò½áµãÁ´½Óµ½newHeadPtrÖ¸ÏòÁ´±íµÄβ½áµãÖ®ºó*/ currentPtr=headPtr;

while(currentPtr->nextPtr!=NULL)//Èô²»ÊÇ×îºó½áµã

currentPtr=currentPtr->nextPtr;

currentPtr->nextPtr=lastPtr; //½«Î²½áµãÁ´½Óµ½Á´±í

return headPtr;

}

}

LISTNODEPTR mergeSortList(LISTNODEPTR head1Ptr,LISTNODEPTR head2Ptr)

{

LISTNODEPTR left2Ptr,previous1Ptr,current1Ptr,previous2Ptr,current2Ptr;

while(head2Ptr!=NULL)

{

previous1Ptr=NULL;

current1Ptr=NULL;

previous2Ptr=NULL;

current2Ptr=NULL;

left2Ptr=head2Ptr;

/*1。

ÕÒ²åÈëλÖ㺸ù¾ÝÁ´±í2µÄµ±Ç°ÔªËØÕÒµ½ÔÚÁ´±í1µÄ²åÈëλÖÃ,½«²å

Èëµ½previous1PtrºÍcurrent1PtrÖ¸ÏòµÄ½áµãÖ®¼ä£»*/

findPos(head1Ptr,left2Ptr->data,&previous1Ptr,&current1Ptr);

if(current1Ptr==NULL)

{ /*ÈôÁ´±í1ÖÐËùÓÐÔªËؾùСÓÚÁ´±í2µÄµ±Ç°

ÔªËØ£¬Ôò½«Á´±í2ÕûÌåÁ´½Óµ½Á´±í1µÄβ²¿ */

previous1Ptr->nextPtr=left2Ptr; //Á´±í2Ö±½ÓÁ¬µ½Á´±í1ÉÏ£»

head2Ptr=NULL;//ǧÍò²»¿ÉÍüÁËд£¬·ñÔòËÀÑ­»·

}

else

{//Èô²»ÊDzåÈëµ½Á´±í1β²¿

/*2。

±È½Ï²¢È·¶¨Á´±í2±¾´Î¿É¹é²¢µÄÁ¬ÐøK¸ö½áµã£»Õâ¶Î½áµãÓÉleft2PtrºÍ previous2PtrÖ¸Ïò */

findPos(head2Ptr,current1Ptr->data,&previous2Ptr,&current2Ptr);

/*3。

½«Á´±í2µÄÓÉleft2PtrºÍprevious2PtrÖ¸ÏòµÄÁ¬Ðø½áµã¹é²¢µ½Á´±í1 */

if(current1Ptr==head1Ptr)

{ //Èô²åÈëµ½Á´±í1Í·½áµãÇ°

previous2Ptr->nextPtr=head1Ptr;

head1Ptr=left2Ptr;

}

else

{ //Èô²åµ½Á´±íÖмä

previous1Ptr->nextPtr=left2Ptr;

previous2Ptr->nextPtr=current1Ptr;

}

head2Ptr=current2Ptr;//ÈôÁ´±í2ÖÐÎÞ½áµãÁË£¬Ôò´Ëʱcurrent2PtrΪ¿Õ

}

} //END OF WHILE

return head1Ptr;

}

void findPos(LISTNODEPTR headPtr,int value,LISTNODEPTR * previousPtr,LISTNODEPTR * currentPtr)

{

LISTNODEPTR currentPtrTemp,previousPtrTemp;

currentPtrTemp=headPtr;

previousPtrTemp=NULL;

while (currentPtrTemp!=NULL &&

currentPtrTemp->datanextPtr;

}

*previousPtr=previousPtrTemp;

*currentPtr=currentPtrTemp;

}

这是一个综合链表操作，你可以好好研究。

至于那些乱码的文字，。你可以忽略了。

全部

甄藏阁
关注
C语言实现链表创建
想坐在电脑前吹空调
06-01 8972
对链表的认识和理解，链表的一些基础知识，C语言用尾插法创建链表。
C语言来实现链表创建
热门推荐
xinzhilinger的博客
10-11 3万+
前言 链表是数据结构中很重要的内容，要想学会数据结构，首先要了解链表 链表的基本知识 1，链表的构成 链表是由一个头指针和一个个节点构成的，如图： 而节点则是一个个结构体，包含数据域和指针域两部分，其中，指针域存储的是指向下一个节点的指针 2，对于链表的操作 1，创建链表 2，初始化链表 3，遍历链表 4，对于链表进行增删查等操作 C语言对于链表的代码的实现 1，创建结构体并命名 创建链表前需要先创建结构体作为节点和头指针： typedef struct Node //typedef方法函数可以对于st
c语言链表创建
10-23
详细用c语言创建链表，通俗易懂链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类，头结点和一般节点，头结点是没有数据域的。链表中每个节点都分为两部分，一个数据域，一个是指针域。说到这里你应该就明白了，链表就如同车链子一样，head指向第一个元素：第一个元素又指向第二个元素；……，直到最后一个元素，该元素不再指向其它元素，它称为“表尾”，它的地址部分放一个“NULL”（表示“空地址”），链表到此结束。
C语言创建链表
aixiaoli2923的博客
09-10 2195
一、链表中结点的存储 链表的结点左边一部分是存放的数据，右边一部分是后继指针指向下一个结点的地址。C语言中通常定义一个结构体类型来存储一个结点，如下： struct node { int data; struce node *next; //下一个结点的类型也是struct node，所以后继指针的类型也必须是struct node * };...
输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
lyl194458的博客
04-29 294
题目：输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。 分析：先将链表数据尾插到一个vector中，再将这个vector反转。(当然也可以头插) vector<int> printListFromTailToHead(ListNode* head) { ListNode* cur=head; vector&...
链表的输入与输出
umgsai的专栏
08-10 335
#include"stdio.h" #include"malloc.h" typedefstructNode {chardata; structNode*next; }Node,*Linklist; voidInput(Linklist&amp;p)//输入函数 {Node*r,*s; r=p; charc; intflag=1; whi...
C语言实现输出链表中倒数第k个节点
09-04
然后，它使用两个指针 `pKnode` 和 `head` 分别遍历链表，先移动 `k` 步使 `pKnode` 指向倒数第k个节点的前一个节点，再同时移动两个指针直到 `head` 达到链表末尾。此时 `pKnode` 将指向倒数第k个节点。 在 `main`...
C语言静态链表和动态链表
09-02
静态链表的一个例子是使用结构体和结构体指针来构建的链表，例如上述代码中的`struct node`。 在示例代码中，`struct node`定义了一个包含整型数据`data`和结构体指针`next`的结构。`a`、`b`、`c`是三个`struct ...
C语言链表-创建链表并且从键盘输入赋值
0rambot的博客
10-03 2万+
链表是C语言里面学习比较困难的一部分内容，下面这个例子就演示了创建一个链表并且从输入端赋值，希望对大家有用。#include #include struct link { int num; struct link *next; }; int main() { int n,i; struct link *head,*p; printf("How many
C语言2种方式实现简单单链表的创建
02-02
C语言：数组创建单链表；键盘输入数值创建单链表。 int main() { pNode tmp=(pNode)malloc(sizeof(struct Node) ); tmp=creatList(); tmp=inputCreatList(); return 0; }
链表输入
weixin_45653525的博客
12-16 632
#include <stdio.h> #include <stdlib.h> struct List { int data; struct List *next; } * a; struct List *cin(); void cout(struct List *head); int main() { a = cin(); cout(a); ...
C语言—单链表的创建与插入操作
Char_kar的博客
01-02 2414
C语言—单链表的创建与插入操作
基于C语言的链表的创建
navylhjjlh的博客
03-10 4110
基于C语言的链表的创建
C语言创建一个单链表实现键盘输入数据以及增删查
m0_51415606的博客
10-18 1万+
作为一个编程小白，在这里发表自己的第一篇博客，心里还是有点紧张。写博客的目的主要还是在于让自己对所学的知识进行充分的掌握，企图在写分析的过程当中可以达到“柳暗花明又一村”的境界，当然如果可以帮助到别人的话自己心里也肯定有辣么一点点成就感。 因为刚接触到链表，所以今天就想和大家一起探讨一下链表。想弄清楚链表，对指针的概念一定要很清楚。我们都知道，链表是由一个又一个节点构成，每个节点又分为数据域和指针域（eg：p->data/p->next）。 ![在这里插入图片描述](https://img.
C语言链表的创建，插入，增，删，查，改，输出
m0_57868995的博客
02-08 927
C语言链表的创建，插入，增，删，查，改，输出
简单例子说明如何建立链表（C语言）
XXT2018的博客
03-19 359
我们根据下图建立链表： 假设有三个学生，他们的学号、分数分别储存在链表里。要求建立链表并输出这些信息。 #include<stdio.h> struct student{ int num; float score; struct student *next; /*指向结构的指针*/ }; main(){ struct student stu1, stu...
C语言输入一个链表，输出这个链表的倒数第K个节点
最新发布
06-13
在C语言中，要输入一个链表并输出其倒数第K个节点，首先你需要创建一个链表结构，然后实现一个方法来遍历链表，找到倒数第K个节点。这里是一个简单的步骤说明： 1. **定义链表结构**： 假设链表节点定义如下： ``...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值