11链表相关算法

2022-07-01 12:32:27 阅读：168 来源： 互联网

标签：11 PNOTE int list 链表算法 pHead 节点 pNext

链表算法

遍历
查找
清空
销毁
求长度
排序
删除节点

插入节点

//分配一个临时节点,不存放有效数据的头结点。pHead为指向头结点的指针变量（头指针）
    PNODE pHead = (PNODE)malloc(sizeof(NODE));//函数内的pHead为局部变量（临时存储）
    if(NULL == pHead)
    {
        printf("分配失败，程序终止！\n");
        exit(-1);
    }

主程序

# include <stdio.h>
# include <malloc.h>

//数据类型
typedef struct Node
{
    int data;//数据域
    struct Node * pNext;//指针域
}NOTE, * PNOTE;//NOTE等价于struct Node, *PNOTE等价于struct Node *

//函数声明
PNOTE create_list(void);
void traverse_list(PNOTE pHeat);//遍历链表
bool is_empty(PNOTE pHead);
int length_list(PNOTE pHeat);
bool insert_list(PNOTE, int , int);
bool delete_list(PNODE, int, int *);//int *返回删除的值的地址，用于释放内存
void soert_list(PNODE);

int main(void)
{
    PNOTE pHeat = NULL;//等价于struct Node * pHeat = NULL;
    pHeat = create_list();//create_list()功能：创建一个非循环单链表，并将该链表的头结点的地址付给pHeat
    traverse_list(pHead);
    //在链表位置pos前插入数值val
    //inset_list(pHeat, 4, 33);
    if(delete_list(pHead, 4, &val))
    {
        printf("删除成功，您删除的元素是：%d\n",val);
    }
    else
    {
        print("删除失败，您删除的元素不存在！\n");
    }
    //链表是否为空
    if(is_empty(pHeat))
        printf("链表为空！\n");
    else
        printf("链表为不空！\n");
    return 0;
    //链表长度
    len = int length_list(PNOTE pHeat);
    printf("链表长度是%d\n", len);
}


//创建链表
PNOTE create_list(void)
{
    int len;//存放有效节点的个数
    int i;
    int val;//临时存放用户输入的节点的值
    
    //分配一个临时节点,不存放有效数据的头结点。pHead为指向头结点的指针变量（头指针）
    PNODE pHead = (PNODE)malloc(sizeof(NODE));//函数内的pHead为局部变量（临时存储）
    if(NULL == pHead)
    {
        printf("分配失败，程序终止！\n");
        exit(-1);
    }
    PNOTE pTail = pHead;
    pTail->pNext = NULL;//指向新节点的指针赋值给pTail，保证pTail永远指向最后一个节点
    
    printf("请输入您需要生成链表节点的个数：len =");
    scanf("%d",&len);
    for(i=0; i<len; ++i)
    {
        printf("请输入第%d个节点的值"， i+1);
        scanf("%d", &val);
        PNODE pNew = (PNODE)malloc(sizeof(NODE));
        if(NULL == pNew)
        {
             printf("分配失败，程序终止！\n");
             exit(-1);
        }
        pNew->data = val;
        pTail->pNext = pNew;
        pNew->pNext = NULL;
        pTail = pNew;
    }
    return pHead;
}
//遍历链表
void traverse_list(PNOTE pHead)//用while循环方便些
{
    PNOTE p = pHeat->pNext;
    while (NULL != P)
    {
        printf("%d", p->data);
        p = p->pNext;//指针移动
    }
    printf("\n");
}
//判断链表是否为空
bool is_empty(PNOTE pHead)
{
    if(NULL == pHeat->pNext)
        reture true;
    else
        reture false;
}
//判断链表长度
int length_list(PNOTE pHeat)
{
    int len=0;
    PNOTE p = pHeat->pNext;
    while(NULL!=p)
    {
        ++len;
    }
    reture len;
}
//排序（知识点串讲）
void sort_list(PNOTE pHead)
{
    PNOTE p,q;
    int t;
    for(p=pHead; p->pHead != NULL; p=p->pHead)
    {
       for(q=p->pHead;  q->pHead != NULL; q=q->pHead)
       {
           if(p->date>q->q->date)
           {
               t = p->date;
               p->date = q->q->date;
               q->q->date = p->date;
           }
       }
    }
    return ;   
}
//在pHead所指向的链表的第pos个节点的前面插入一个新节点。该节点的值是val,并且pos从1开始
bool insert_list(PNOTE pHead, int pos, int val)
{
    //找pos-1的地址
    int i = 0;
    PNODE p = pHead;
    while(NULL!=p && i<pos-1)//判断插入的位置合理
    {
        p = p->pNext;
        ++i;
    }
    if(i>pos-1 || NULL==p)
        return false;
    //新成立一个节点
    PNOTE pNew = (PNOTE)malloc(sizeof(NOTE));
    if(NULL == pNew)
    {
        print("动态分配内存失败！\n");
        exit(-1);
    }
    pNew->data = val;//赋予新节点值
    PNODE q = p->pNext;//取出插入节点位置的下一节点地址
    p->pNext = pNew;//赋予新节点地址
    pNew->pNext = q;//新节点连接下一插入位置的下一节点
}
//删除节点
bool delete_list(PNODE, int pos, int * pVal);
{
    //找到位置
   int i = 0;
    PNODE p = pHead;
    while(NULL!=p && i<pos-1)//判断插入的位置合理
    {
        p = p->pNext;
        ++i;
    }
    if(i>pos-1 || NULL==p)
        return false; 
    //实现p节点后一节点删除
    PNOTE q = p->pNext;//取出删除节点地址
    *pVal = q->data;//取出删除节点值
    p->pNext = p->pNext->pNext;//删除节点的下个节点地址p->pNext->pNext直接赋值给前个节点的p->pNext
    free(q);//释放被删除节点内存
    q = NULL;
    return ture;
}

pHeat->pNext = pNew;
pNew->pNext = NULL;//将临时节点指针域清空给下个节点用

普通数组中的冒泡排序

void sort_arr(int * a, int len)
{
    int i,j,t;
    for(i=0; i<len-1; ++i)
    {
        for(j=i+1; j<len; ++j)
        {
            if(a[i]>a[j])
            {
                t = a[i];
                a[i] = a[j];
                a[j] = t;
            }
        }
    }
    return ;
}

结构体数组

# include <stdio.h>

//定义一个数据类型，名为struct Arr含有3个成员
struct Arr
{
    int * pBase;//存储的是数组第一个元素的地址
    int len;    //数组所能容纳的最大元素的个数
    int cnt;    //当前数组有效元素的个数
    //int increament;//自动增长因子
}；
void sort_arr(struct Arr * p)
{
    int i,j,t;
    for(i=0; i<p->cnt-1; ++i)
    {
        for(j=i+1; j<p->cnt; ++j)
        {
            if(p->pBase[i]>p->pBase[j])
            {
                t = p->pBase[i];
                p->pBase[i] = p->pBase[j];
                p->pBase[j] = t;
            }
        }
    }
    return ;
}

算法（核心）：

狭义的算法是与数据的存储放式密切相关
广义的算法是与数组的存储放式无关

泛型（核心）：

利用某种技术达到的效果就是：不同的存储方式，执行的操作是一样的

算法学习心得

记流程
每个语句功能
试数和测试
反复的敲写直到熟悉（学习清华高一凡一样）

标签：11,PNOTE,int,list,链表,算法,pHead,节点,pNext
来源： https://www.cnblogs.com/chentongxue/p/16434170.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9