单链表的c语言实现完整c代码,c语言单链表程序代码

发布时间：2022-11-26

本文目录一览：

  1. 求C语言单链表 源代码
  2. c语言 单链表源代码
  3. 求一份实现单链表的基本操作的c语言程序，包括输入元素，谢谢。
  4. 用C语言实现建立一个单链表的过程，并实现打印链表中每一个元素，写出完整程序
  5. 编写一个C语言程序 实现单链表的基本操作

求C语言单链表 源代码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct people
{
    char name[10];
    int age;
    struct people * next;
};
int main()
{
    struct people * head = NULL;
    struct people * prev, * current;
    int flag = 1;
    while(flag != 0)
    {
        printf("请输入学生姓名，年龄：（年龄输入0结束所有输入工作）\n");
        current = (struct people *)malloc(sizeof(struct people));
        if(head == NULL)
            head = current;
        else
            prev->next = current;
        current->next = NULL;
        scanf("%s", current->name);
        scanf("%d", &current->age);
        prev = current;
        flag = current->age;
    }
    printf("Output:\n");
    if(head == NULL)
        printf("无资料。\n");
    else
    {
        current = head;
        while(current->next != NULL)
        {
            printf("姓名：%s\n年龄：%d\n\n", current->name, current->age);
            current = current->next;
        }
    }
}

至于排序，断开旧链表，将前后指针链接到新的节点就好。 如果还有问题欢迎再问哈。

c语言 单链表源代码

#include "stdafx.h"
#include <stdio.h>
#include <malloc.h>
typedef char ElemType;
struct LNode
{
    ElemType data;
    struct LNode *next;
};
//***********************************************************置空表setnull()
void setnull(struct LNode **p)
{
    *p = NULL;
}
//************************************************************求长度length()
int length(struct LNode **p)
{
    int n = 0;
    struct LNode *q = *p;
    while (q != NULL)
    {
        n++;
        q = q->next;
    }
    return(n);
}
//*************************************************************取结点get()
ElemType get(struct LNode **p, int i)
{
    int j = 1;
    struct LNode *q = *p;
    while (j < i && q != NULL) /*查找第i个结点*/
    {
        q = q->next;
        j++;
    }
    if (q != NULL) /*找到了第i个结点*/
        return(q->data);
    else
    {
        printf("位置参数不正确!\n");
        return NULL;
    }
}
//************************************************************按值查找locate()
int locate(struct LNode **p, ElemType x)
{
    int n = 0;
    struct LNode *q = *p;
    while (q != NULL && q->data != x) /*查找data域为x的第一个结点*/
    {
        q = q->next;
        n++;
    }
    if (q == NULL) /*未找到data域等于x的结点*/
        return(-1);
    else /*找到data域等于x的结点*/
        return(n + 1);
}
//**********************************************************插入结点insert()
void insert(struct LNode **p, ElemType x, int i)
{
    int j = 1;
    struct LNode *s, *q;
    s = (struct LNode *)malloc(sizeof(struct LNode)); /*建立要插入的结点s*/
    s->data = x;
    q = *p;
    if (i == 1) /*插入的结点作为头结点*/
    {
        s->next = q;
        *p = s;
    }
    else
    {
        while (j < i - 1 && q->next != NULL) /*查找第i-1个结点*/
        {
            q = q->next;
            j++;
        }
        if (j == i - 1) /*找到了第i-1个结点,由q指向它*/
        {
            s->next = q->next; /*将结点s插入到q结点之后*/
            q->next = s;
        }
        else
            printf("位置参数不正确!\n");
    }
}
//*********************************************************删除结点del()
void del(struct LNode **p, int i)
{
    int j = 1;
    struct LNode *q = *p, *t;
    if (i == 1) /*删除链表的头结点*/
    {
        t = q;
        *p = q->next;
    }
    else
    {
        while (j < i - 1 && q->next != NULL) /*查找第i-1个结点*/
        {
            q = q->next;
            j++;
        }
        if (q->next != NULL && j == i - 1) /*找到第i-1个结点,由q指向它*/
        {
            t = q->next; /*t指向要删除的结点*/
            q->next = t->next; /*将q之后的结点删除*/
        }
        else
            printf("位置参数不正确!\n");
    }
    if (t != NULL) /*在t不为空时释放该结点*/
        free(t);
}
//********************************************************显示链表display()
void display(struct LNode **p)
{
    struct LNode *q;
    q = *p;
    printf("单链表显示:");
    if (q == NULL) /*链表为空时*/
        printf("链表为空!");
    else if (q->next == NULL) /*链表只有一个结点时*/
        printf("%c\n", q->data);
    else
    {
        while (q->next != NULL) /*显示前面的结点*/
        {
            printf("%c→", q->data);
            q = q->next;
        }
        printf("%c", q->data); /*显示最后一个结点*/
    }
    printf("\n");
}
void main()
{
    struct LNode *head;
    setnull(&head);
    insert(&head, 'a', 1);
    insert(&head, 'b', 2);
    insert(&head, 'a', 2);
    insert(&head, 'c', 4);
    insert(&head, 'd', 3);
    insert(&head, 'e', 1);
    display(&head);
    printf("单链表长度=%d\n", length(&head));
    printf("位置:%d 值:%c\n", 3, get(&head, 3));
    printf("值:%c 位置:%d\n", 'a', locate(&head, 'a'));
    printf("删除第1个结点:");
    del(&head, 1);
    display(&head);
    printf("删除第5个结点:");
    del(&head, 5);
    display(&head);
    printf("删除开头3个结点:");
    del(&head, 3);
    del(&head, 2);
    del(&head, 1);
    display(&head);
}

运行结果：

单链表显示:e→a→a→d→b→c
单链表长度=6
位置:3 值:a
值:a 位置:2
删除第1个结点:单链表显示:a→a→d→b→c
删除第5个结点:单链表显示:a→a→d→b
删除开头3个结点:单链表显示:b

求一份实现单链表的基本操作的c语言程序，包括输入元素，谢谢。

#include <stdlib.h>
#include "nodedef.h"
#define CreateLinklistWay 1 // 0表示头插法创建链表，1表示尾插法创建链表
#if !CreateLinklistWay
/*********************************************************************
* 函数名称：linklist *CreateLinklistHead()
* 函数功能：利用头插法创建链表
* 参 数：无
* 返 回 值：创建完链表后的链表头结点
* 说 明：无
*********************************************************************/
extern linklist *CreateLinklistHead()
{
    int x, i, nodeNum;
    linklist *head, *temp; // 头结点与临时结点
    head = (linklist *)malloc(sizeof(linklist)); // 生成表头结点
    head->next = NULL; // 给表头结点的指针域赋值
    printf("请输入链表中结点的个数：");
    scanf("%d", &nodeNum);
    for(i=1; i<=nodeNum; i++)
    {
        printf("请输入第 %d 个结点的数据：", i);
        scanf("%d", &x);
        temp = (linklist *)malloc(sizeof(linklist)); // 生成新的结点
        temp->data = x; // 对新结点的数据域赋值
        // 将新结点插到头结点之后
        temp->next = head->next;
        head->next = temp;
    }
    return head; // 返回新建链表的头结点
}
#else
/*********************************************************************
* 函数名称：linklist *CreateLinklistRear()
* 函数功能：利用尾插法创建链表
* 参 数：无
* 返 回 值：创建完链表后的链表头结点
* 说 明：无
*********************************************************************/
extern linklist *CreateLinklistRear()
{
    int x, i, nodeNum;
    linklist *head, *rear, *temp; // 定义头结点、尾结点和临时结点
    head = (linklist *)malloc(sizeof(linklist)); // 生成表头结点，表头结点不存放数据
    head->next = NULL; // 将表头结点的指针域赋值为NULL
    rear = head; // 将表头结点赋值给表尾结点
    printf("请输入链表中结点的个数：");
    scanf("%d", &nodeNum);
    for(i=1; i<=nodeNum; i++)
    {
        printf("请输入第 %d 个结点的数据：", i);
        scanf("%d", &x);
        temp = (linklist *)malloc(sizeof(linklist)); // 生成新的结点
        temp->data = x; // 新增结点的数据域
        temp->next = NULL; // 新增结点的指针域（由于是尾插法，所以插入的结点都在尾部，即指针域为NULL）
        rear->next = temp; // 使前一个结点指向新增结点(head->next=temp)
        rear = temp; // 将新增结点赋值给尾结点（尾插法，插入的结点在尾部）
    }
    //rear->next = NULL; // 将尾结点的指针域赋值为空（为了方便检验链表是否为空链表）
    return head; // 返回头结点
}
#endif

用C语言实现建立一个单链表的过程，并实现打印链表中每一个元素，写出完整程序

这是个很简单的链表创建和输出。

#include <stdio.h>
#include <stdlib.h>
typedef struct linkednode
{
    char data;
    struct linkednode *next;
} node, *link_list; //链表节点的结构及重命名
link_list creat() //创建一个链表返回类型是链表的首地址
{
    link_list L;
    node *p1, *p2;
    char data;
    L = (node*)malloc(sizeof(node)); //开辟存储空间
    p2 = L;
    while((data = getchar()) != '\n') //输入回车键时结束输入
    {
        p1 = (node*)malloc(sizeof(node));
        p1->data = data;
        p2->next = p1;
        p2 = p1;
    }
    p2->next = NULL;
    return L;
}
void print(link_list L) //把链表输出
{
    node *p;
    p = L->next;
    while(p != NULL)
    {
        printf("%c", p->data);
        p = p->next;
    }
    printf("\n");
}
void main()
{
    link_list L = NULL;
    char x;
    printf("请输入链表节点:\n");
    L = creat();
    print(L);
}

编写一个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);
int 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的下一个节点
    }
}
int is_empty(PNODE pHead)
{
    if(NULL == pHead->pNext)
        return 1;
    else
        return 0;
}
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");
    return 0;
}
void freeer(PNODE pHead)
{
    PNODE pT = pHead;
    while(NULL != pHead->pNext)
    {
        free(pT);
        pT = pT->pNext;
    }
    return;
}

好久以前写的一个链表了，有排序，插入，删除，输出，判断是否为空，甚至还有释放堆中内存的功能。

推荐文章