C语言数据结构——链表

最新推荐文章于 2022-01-12 20:38:46 发布
最新推荐文章于 2022-01-12 20:38:46 发布
阅读量510 收藏 2
点赞数 1
分类专栏： 数据结构与算法分析——C语言描述 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36267036/article/details/115558991
版权 
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

typedef struct Node
{
    int data;       // 数据域
    struct Node * pNext;   // 指针域
}* PNODE, NODE; //NODE等价于struct Node ； PNODE等价于struct Node *

PNODE create_list();  // 创建空链表
void traverse_list(PNODE);  //遍历链表
bool is_empty(PNODE);   //判断链表是否为空
int length_list(PNODE); // 求链表长度
bool insert_list(PNODE, int, int);  // 插入
bool delete_list(PNODE, int, int *);    //删除某一个节点
void sort_list(PNODE);  //排序
bool find(PNODE, int);  // 查找节点
void deleteList(PNODE); // 删除整个链表


int main()
{
    PNODE pHead = NULL; // 等价于 struct Node * pHead = NULL;
    int pos, val;
    pHead = create_list();//创建一个非循环单链表，并将该链表的头结点的地址赋给pHead
    traverse_list(pHead); // 遍历
    if(is_empty(pHead))
        printf("链表为空!\n");
    else
        printf("链表不空!\n");

    printf("链表长度为：%d\n", length_list(pHead));

//    sort_list(pHead);
    traverse_list(pHead); // 遍历
//    printf("请输入要插入的位置和插入的数值\n");
//    scanf("%d%d", &pos, &val);
//    if(insert_list(pHead, pos, val))
//        printf("插入成功\n");
//    else
//        printf("插入失败\n");
//
//    traverse_list(pHead); // 遍历
//    printf("请输入要删除的位置\n");
//    scanf("%d", &pos);
//    if(delete_list(pHead, pos, &val))
//        printf("删除%d成功\n", val);
//    else
//        printf("删除失败\n");
//    printf("输入要查询的值:");
//    scanf("%d", &val);
//    if(find(pHead, val)) printf("找到了\n");
//    else printf("没找到\n");
    deleteList(pHead);
    traverse_list(pHead); // 遍历
    return 0;
}

PNODE create_list()
{
    int len; // 用来存放有效节点的个数
    int i, val; // val：用来临时存放用户输入的节点的值

    // 分配了一个不存放有效数据的头结点
    PNODE pHead = (PNODE) malloc(sizeof(NODE));
    if(pHead == NULL)
    {
        printf("分配失败，程序终止!\n");
        exit(-1);
    }
    PNODE pTail = pHead;
    pTail->pNext = NULL;  // pTail指向尾结点

    printf("请输入您需要生成的链表节点的个数:len = ");
    scanf("%d", &len);

    for(i = 0 ; i < len; i++)
    {
        printf("请输入第%d个节点的值：", i);
        scanf("%d", &val);

        PNODE pNew = (PNODE) malloc(sizeof(NODE));

        if(pNew == NULL)
        {
            printf("分配失败，程序终止!\n");
            exit(-1);
        }
        pNew->data = val;
        pTail->pNext = pNew;
        pNew->pNext = NULL;
        pTail = pNew;
    }

    return pHead;
}

void traverse_list(PNODE pHead)
{
    PNODE p = pHead->pNext;
    if(p == NULL)
    {
        printf("链表为空\n");
        return ;
    }
    while(p != NULL)
    {
        printf("%d ", p->data);
        p = p->pNext;
    }
    printf("\n");
}

bool is_empty(PNODE pHead)
{
    if(pHead->pNext == NULL)
        return true;
    else
        return false;
}

int length_list(PNODE pHead)
{
    int cnt = 0;
    while(pHead->pNext != NULL)
    {
        cnt++;
        pHead = pHead->pNext;
    }
    return cnt;
}

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 - 1; ++i, p = p->pNext)
        for(j = i + 1, q = p->pNext; j < len; ++j, q = q->pNext)
        {
            if(p->data > q->data)
            {
                 t = p->data;
                 p->data = q->data;
                 q->data = t;
            }
        }
    return;
}

//在pHead所指向链表的第pos个节点的前面插入一个新的节点，该节点的值是val，并且pos的值从1开始
bool insert_list(PNODE pHead, int pos, int val)
{
    int i = 0;
    PNODE p = pHead;

    //循环正常结束，p节点是pos前一个节点
    while(p != NULL && i < pos - 1)
    {
        p = p->pNext;
        ++i;
    }

    /*
        1.如果pos输入负数或者是0时
        2.避免中间出现NULL的，例如有5个节点，但是要在第7个节点的位置插入，因为没有第6个节点。
        遇到这两种情况则插入失败
    */
    if(i > pos - 1 || p == NULL)
        return false;

    PNODE pNew = (PNODE) malloc(sizeof(NODE));
    if(pNew == NULL)
    {
        printf("动态分配内存失败\n");
        exit(-1);
    }

    pNew->data = val;
    PNODE q = p->pNext;
    p->pNext = pNew;
    pNew->pNext = q;

    return true;
}

bool delete_list(PNODE pHead, int pos, int * pVal)
{
    int i = 0;
    PNODE p = pHead;

    //循环正常结束，p节点是pos前一个节点
    while(p->pNext != NULL && i < pos - 1)
    {
        p = p->pNext;
        ++i;
    }

    // 如果只有一个头结点或pos≤0时，删除失败
    if(i > pos - 1 || p->pNext == NULL)
        return false;

    PNODE q = p->pNext;
    *pVal = q->data;

    //删除p节点后边的节点
    p->pNext = p->pNext->pNext;
    free(q);
    q = NULL;

    return true;
}

bool find(PNODE pHead, int val)
{
    PNODE p;
    p = pHead->pNext;
    while(p != NULL && p->data != val)
        p = p->pNext;

    if(p == NULL)
    {
        free(p);
        return false;
    }
    else
    {
        free(p);
        return true;
    }
}

void deleteList(PNODE pHead)
{
    PNODE p, Tmp = NULL;
    p = pHead->pNext;
    while(p != NULL)
    {
        Tmp = p->pNext;
        free(p);
        p = Tmp;
    }
    pHead->pNext = NULL;
}


#include<stdio.h>
#include<stdlib.h>

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

#define MAXSIZE 100

typedef int Status;
typedef int ElemType;


typedef struct Lnode
{
    ElemType data;
    struct Lnode *next;
}LNode, *LinkList;


// 头插法
void CreateList_Head(LinkList L, int n) {
    L->next = NULL; // 先建立一个带头结点的单链表
	for (int i = 0; i < n; i++)
	{
		LNode *p = (LNode *)malloc(sizeof(LNode));
        scanf("%d", &(p->data));
		p->next = L->next;
		L->next = p;
	}
}

// 尾插法
void CreateList_R(LinkList L, int n)
{
    LinkList q = L;
    while(q->next)      // q是尾指针
        q = q->next;
    for(int i = 0; i < n; i++)
    {
        LNode *p = (LNode *) malloc(sizeof(LNode));
        scanf("%d", &(p->data));
        p->next = NULL;
        q->next = p;
        q = p;
    }
}

// 遍历链表
void Traverse(LinkList L)
{
    if(L == NULL)
    {
        printf("链表不存在\n");
        return ;
    }
    LinkList q = L->next;
    int i = 1;
    if(q == NULL)
    {
        printf("链表为空\n");
        return ;
    }


    while(q != NULL)
    {
        printf("%d-----data:%d\n", i, q->data);
        i++;
        q = q->next;
    }
}


// 初始化链表
Status InitList_L(LinkList *L)
{
    *L = (LinkList) malloc(sizeof(LNode));
    if(*L == NULL)
    {
        printf("内部不足，空间分配失败\n");
        return ERROR;
    }

    (*L)->next = NULL;
    return OK;
}


// 销毁链表
Status DestroyList_L(LinkList *L)
{
    LinkList p, tmp;

    p = (*L)->next;
    *L = NULL;
    while(p)
    {
        tmp = p;
        p = p->next;
        free(tmp);
    }
    return OK;
}

// 清空链表
Status ClearList(LinkList L)
{
    LinkList p, q;
    p = L->next;
    while(p)
    {
        q = p->next;
        free(p);
        p = q;
    }
    L->next = NULL;
    return OK;
}


// 求链表长度
int ListLength_L(LinkList L)    // 返回L总数据元素的个数
{
    int i = 0;
    LinkList p = L->next;
    while(p)
    {
        i++;
        p = p->next;
    }
    return i;
}

// 获取线性表L中的某个数据元素的内容，通过变量e返回
Status GetElem_L(LinkList L, int i, ElemType *e)
{
    LinkList p = L->next;
    int j = 1;
    while(p && j < i)   // 向后扫描，直到p指向第i个元素或p为空
    {
        p = p->next;
        ++j;
    }
    if(!p || j > i) return ERROR; // 第i个元素不存在
    *e = p->data;
    return OK;
}

// 在线性表L中查找值为e的数据元素
// 找到，则返回L中值为e的数据元素的地址，查找失败返回NULL
LNode *LocateElem_L(LinkList L, ElemType e)
{
    LinkList p = L->next;
    while(p && p->data != e)
        p = p->next;
    return p;
}

// 在L中第i个元素之前插入数据元素e
Status LinkInsert_L(LinkList L, int i, ElemType e)
{
    LinkList p = L, q;
    int j = 0;
    while(p && j < i - 1)       // 寻找第i-1个节点，p指向i-1节点
    {
        p = p->next;
        j++;
    }
    if(!p || j > i - 1) return ERROR;   // i大于表长+1或者小于1，插入位置非法
    q = (LinkList) malloc(sizeof(LNode));
    q->data = e;
    q->next = p->next;
    p->next = q;
    return OK;
}

int main()
{
    LinkList L = NULL, p = NULL;
    InitList_L(&L);
    CreateList_Head(L, 3);
    CreateList_R(L, 3);
    Traverse(L);

    return 0;
}

参考：数据结构与算法基础（青岛大学-王卓）

铁头娃小蓝
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构include文件夹
12-01
适合学C++的人，学数据结构必备 包含了许多头文件，直接拿来用就可以了
数据结构#include
01-05
#include #include #define ok 1 #define error 0 #define overflow -1 #define LIST_INIT_SIZE typedef int ElemType; typedef int Status; typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList; #include #include #define ok 1 #define error 0 #define overflow -1 #define LIST_INIT_SIZE typedef int ElemType; typedef int Status; typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList;
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
C语言程序设计现代方法第二版 第十章答案（上）
qq_29445129的博客
04-01 1999
1： #include <stdio.h> #include<string> #define STACK_SIZE 100 int top = 0; char contents[STACK_SIZE]; void make_empty(void) { top = 0; } bool is_empty(void) { return top == 0; } bool is_...
双向链表的基本操作（C语言）
tengfeigoon的专栏
04-04 940
这是我自己写的小模块，用于实现双向链表的基本操作，不知道是不是最好的算法，希望大家多提意见我们先定义两个数据结构：typedef struct mng{int longth; /*链表的长度*/LTBL *top;/*指向链表头的指针*/}MNG;typedef struct ltbl{LTBL *fp;}
数据结构--链表
weixin_51552144的博客
12-16 720
文章目录单链表链表插入头插入尾插法链表删除链表遍历双链表双循环链表 单链表 #include<stdio.h> #include<stdlib.h> // 定义结构体 typedef struct link{ int elem; // 代表数据域 struct link *next; // 代表指针域 }link; // 初始化链表 link *creatlink(){ link *p = (link*)malloc(sizeof(link)); // 声明一
C语言数据结构数的实验
hxhxhxhxx的博客
07-07 351
#include<stdio.h> #include<stdlib.h> #include<malloc.h> #include<string.h> #define OK 1 #define ERROR 0 #define OVERFLOW -1 #define STACK_INIT_SIZE 50 typedef int Status; typedef char ElemType; //树节点 typedef struct BiTNode{ Elem
单向循环链表的基本操作
qq_32659129的博客
10-27 1427
单向循环链表的增、删和打印 #include <stdio.h> #include<stdlib.h> typedef struct Node{ int data; struct Node* next; }Node,*LinkList; struct Node* InitLinkList(LinkList L) { L = (Node *)malloc(sizeof(Node)); L->data = 0; L->next = L; return L; }
C语言 链表
a153250的博客
04-30 101
C语言 链表 链表 **结点：**每个空间采用动态数据分配，，每个数据空间保存一个数据，可以根据需求分配数据空间数，而每个数据空间就叫做一个结点。每个结点结构中，我们定义一个成员存放下一个结点的首地址，用于存放下一个结点的成员，这个称为指针域 **链表：**第一个结点的指针域存放下一个结点的首地址，以此内推一直到最后一个结点，最后一个结点的指针域指向Null。 ...
C语言链表
只是个人笔记，请见谅
03-29 296
#include <stdio.h> #include <stdlib.h> #define LEN sizeof(struct student) struct student { long num; float socre; struct student *p; }; int n; void main() { struct student *head; struct student *p1,*p2; n=0; p1=p2=( struct student *)m
针对在校大学生的C语言入门学习——链表源码
01-26
还是象征性的要大家1个积分
数据结构——链表（C语言版）
06-22
个人觉得这个文档资源还是不错的。内容讲解的很详实。
数据结构——单链表.zip
09-16
完全实现严蔚敏数据结构教材中的单链表，可测试。包含初始化，插入，删除，连接等操作
数据结构——用现有链表转换为顺序表
06-26
用链表创建顺序表，本代码是在大学阶段我自己手写的，比较适合正在学习数据结构的朋友，简单易懂。
数据结构
helloliyibo的博客
05-14 362
#include #include #include #define Max 20000 #define NUM 100 typedef struct {     int adj;//相邻接的景点之间的路程 }ArcCell;//定义边的类型 typedef struct jingdian {     int number;//景点编号     char *view;//景
链表详解（C语言）
爱她就要努力
03-16 631
https://www.cnblogs.com/ariel-dreamland/p/10469696.html 链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。 链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。 链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类...
c语言文件
qq_49431764的博客
11-27 746
1. #include <stdio.h> #include <string.h> #include <stdlib.h> int main() { FILE *fp,*fq; char a[100],*s; if((fp=fopen("d:\\file1.txt","r"))==NULL) {printf("can not open file!\n");exit(0);} if((fq=fopen("d:\\file2.txt","w"))==NULL) {prin.
学习C语言——学习笔记（1）
wzwpy99的博客
01-12 1181
1.预处理指令 预处理指令解释为由预处理器读入源码，然后根据预处理指令对其进行修改，最后将修改过后的源代码递交给编译器 以下5行都是预处理指令： #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX_COLS 20 #define MAX_INPUT 1000 预处理指令的作用仿佛是将stdio.h的内容逐字写到源文件的位置，以上第二、三条指令的功能都类似，不同点在于二、三条替换
C语言作业1
qq_50965671的博客
06-03 939
#include<stdio.h> #include<stdlib.h> #include<string.h> int main() { char str[100]; while(gets(str)!=NULL) { int num[4]={0}; int min=100; int len=strlen(str); for(int i=0;i<len;i++) { if(str[i]=='2') num[0]++; .
数据结构——用c语言描述(第3版)课后答案
最新发布
10-25
《数据结构——用C语言描述（第3版）》课后答案的描述使用C语言来实现各种数据结构和算法。以下是对几个常见数据结构的描述和相关代码示例。 1. 数组（Array）：数组是一种线性数据结构，用于存储相同类型的元素。C语言中使用数组可以快速访问和修改元素。示例代码如下： ```c #include <stdio.h> int main() { int arr[5] = {1, 2, 3, 4, 5}; for(int i = 0; i < 5; i++) { printf("%d ", arr[i]); } return 0; } ``` 2. 链表（Linked List）：链表是一种动态数据结构，通过节点之间的指针链接来存储数据。C语言中可以使用结构体和指针来实现链表。示例代码如下： ```c #include <stdio.h> #include <stdlib.h> struct Node { int data; struct Node* next; }; void printList(struct Node* head) { struct Node* current = head; while(current != NULL) { printf("%d ", current->data); current = current->next; } } int main() { struct Node* head = NULL; struct Node* second = NULL; struct Node* third = NULL; head = (struct Node*) malloc(sizeof(struct Node)); second = (struct Node*) malloc(sizeof(struct Node)); third = (struct Node*) malloc(sizeof(struct Node)); head->data = 1; head->next = second; second->data = 2; second->next = third; third->data = 3; third->next = NULL; printList(head); return 0; } ``` 3. 栈（Stack）：栈是一种后进先出（LIFO）的数据结构，在C语言中可以使用数组来实现。示例代码如下： ```c #include <stdio.h> #define MAX_SIZE 100 int stack[MAX_SIZE]; int top = -1; void push(int item) { if(top == MAX_SIZE - 1) { printf("Stack Overflow\n"); } else { stack[++top] = item; } } int pop() { if(top == -1) { printf("Stack Underflow\n"); return -1; } else { return stack[top--]; } } void printStack() { for(int i = top; i >= 0; i--) { printf("%d ", stack[i]); } } int main() { push(1); push(2); push(3); printf("Popped element: %d\n", pop()); printStack(); return 0; } ``` 这些示例代码展示了如何使用C语言描述《数据结构——用C语言描述（第3版）》中介绍的数据结构。读者可以根据书中提供的习题进行编程练习，进一步巩固数据结构和算法的相关知识。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值