【郝斌数据结构自学笔记】27-29_链表插入和删除算法的演示_复习

27_如何学习算法自己的一些感想

28_链表插入和删除算法的演示

#include<stdio.h>

#include<malloc.h>

#include<stdlib.h>

 

typedefstruct Node

{

         int data;//数据域

         struct Node * pNext;//指针域

}NODE,*PNODE;//NODE等价于structNode，PNODE等价于struct Node *

//函数声明

PNODEcreate_list(void);

voidtraverse_list(PNODE pHead);

boolis_empty(PNODE pHead);

intlength_list(PNODE);

boolinsert_list(PNODE,int,int);

booldelete_list(PNODE,int,int*);

voidsort_list(PNODE);

 

 

intmain(void)

{

         PNODE pHead=NULL;//等价于structNode *pHead=NULL；

         int val;

         pHead=create_list();//creat_list()功能：创建一个非循环单链表,并将该链表的头节点的地址付给pHead

         traverse_list(pHead);

         int len=length_list(pHead);

         printf("链表长度是%d\n",len);

 

         if(is_empty(pHead))

                   printf("链表为空！\n");

         else

                   printf("链表不空！\n");

         sort_list(pHead);

         traverse_list(pHead);

         insert_list(pHead,4,33);

         traverse_list(pHead);

         if (delete_list(pHead,4,&val))

         {

                   printf("删除成功，您删除的元素是：%d\n",val);

         }

         else

         {

                   printf("删除失败！您删除的元素不存在!\n");

         }

         traverse_list(pHead);

 

         return 0;

}

 

PNODEcreate_list(void)

{

         int len;//用来存放有效节点的个数

         int i;

         int val;//用来临时存放用户输入的节点的值

 

         //分配了一个不存放有效数据的头节点

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

         if(NULL==pHead)

         {

                   printf("分配失败，程序终止！\n");

                   exit(-1);

         }

         PNODE pTail=pHead;

         pTail->pNext=NULL;

         printf("请输入您需要生成的链表节点的个数：len=");

         scanf("%d",&len);

 

         for (i=0;i<len;i++)

         {

                   printf("请输入第%d个节点的值:",i+1);

                   scanf("%d",&val);

 

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

                   if(NULL==pNew)

                   {

                            printf("分配失败，程序终止！\n");

                            exit(-1);

                   }

                   pNew->data=val;//挂

                   pTail->pNext=pNew;

                   pNew->pNext=NULL;

                   pTail=pNew;

        

         }

         return pHead;

}

 

voidtraverse_list(PNODE pHead)

{

         PNODE p=pHead->pNext;

         while(NULL!=p)

         {

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

                   p=p->pNext;//不连续，不能用p++

         }

         printf("\n");

         return;

}

 

boolis_empty(PNODE pHead)

{

         if(pHead->pNext==NULL)

                   return true;

         else

                   return false;

}

 

intlength_list(PNODE pHead)

{

         PNODE p=pHead->pNext;

         int len=0;

         while(NULL!=p)

         {

                   len++;

                   p=p->pNext;

         }

         return len;

}

 

voidsort_list(PNODE pHead)

{

         int i,j,t;

         int len=length_list(pHead);

         PNODE p,q;

         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)//类似于数组中的：a[i]>a[j]

                            {

                                     t=p->data;//类似于数组中的：     t=a[i];

                                     p->data=q->data;//类似于数组中的： a[i]=a[j];

                                     q->data=t;//类似于数组中的：     a[j]=t;

                            }

                   }

         }

 

}

 

//在pHead所指向链表的第pos个节点的前面插入一个新的节点，新节点的值是val，并且pos的值是从1开始

boolinsert_list(PNODE pHead,int pos,int val)

{

         int i=0;

         PNODE p=pHead;

 

         while(NULL!=p&&i<pos-1)

         {

                   p=p->pNext;

                   ++i;

         }

         if(i>pos-1||NULL==p)

                   return false;

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

         if(NULL==pNew)

         {

                   printf("动态分配内存失败！\n");

                   exit(-1);

         }

         pNew->data=val;

 

         PNODE q=p->pNext;

         p->pNext=pNew;

         pNew->pNext=q;

         return true;

 

}

 

booldelete_list(PNODE pHead,int pos,int* pVal)

{

         int i=0;

         PNODE p=pHead;

 

         while(NULL!=p->pNext&&i<pos-1)

         {

                   p=p->pNext;

                   ++i;

         }

         if(i>pos-1||NULL==p->pNext)

                   return false;

         PNODE q=p->pNext;

         *pVal=q->data;

         //删除p节点后面的节点

         p->pNext=p->pNext->pNext;

         free(q);

         q=NULL;

 

}

29_复习

数据结构

狭义：

                  数据结构是专门研究数据存储的问题

数据的存储包含两方面：个体的存储+个体关系的存储

         广义：

                   数据结构既包括数据的存储也包括数据的操作

对存储数据的操作就是算法

算法

         狭义：

                   算法是和数据的存储方式密切相关

         广义：

                   算法和数据的存储方式无关

                   这就是泛型思想

 

数据的存储方式有几种

线性

         连续存储【数组】

                   优点

                            存取速度很快

                   缺点

                            事先需要知道数组的长度

                            插入删除元素很慢

空间通常有限制

需要大块连续的内存块

         离散存储【链表】

                   优点

                            空间没有限制

                            插入删除元素很快

                   缺点

                            存取速度很慢

         线性结构的应用--栈

         线性结构的应用--队列

非线性

         树

图