【链表】————第九天

/*静态链表示*/

#include 
#include 
 
typedef struct LNode{
    int id;
    char name[128];
    float score;
    struct LNode *next;
}LNode;

void fun(void)
{
    LNode student1={1,"aaa",11.11};
    LNode student2={2,"bbb",22.22};
    LNode student3={3,"ccc",33.33};
    
    LNode *head=NULL;
    head = &student1;
    student1.next=&student2;
    student2.next=&student3;
    student3.next=NULL;
    
    while(head!=NULL)
    {
        printf("id=%d,  name:%s,  score=%.2f\n",head->id,head->name,head->score);
        head=head->next;
    }
}
int main()
{
    fun();
}

/*编译结果：
id=1,  name:aaa,  score=11.11
id=2,  name:bbb,  score=22.22
id=3,  name:ccc,  score=33.33
*/
//动态链表应用：必须动态开辟节点空间，如果用定义结构体变量的方式来编写，函数执行结束之后，该空间就会被释放，节点创建失败；如果用静态局部变量，第一次开辟空间后不在进行创建新的空间，只会改变其中的数值。

/*malloc函数 && free函数 */

#include 
#include 
 
typedef struct LNode{
    int id;
    char name[128];
    float score;
    struct LNode *next;
}LNode,*LinkList;

LNode* fun0(void)
{
    LNode* p=(LNode*)malloc(sizeof(LNode));
    printf("00输入\n");
    scanf("%d%s%f",&p->id,p->name,&p->score);
    return p;
}

LinkList fun1(void)
{
    LinkList p=(LinkList)malloc(sizeof(LNode));
    printf("11输入\n");
    scanf("%d%s%f",&p->id,p->name,&p->score);
    return p;
}
int main()
{
    LNode *p=NULL;
    LinkList q=NULL;
    p=fun0();
    q=fun1();
    printf("LNode:id=%d,  name:%s,  score=%.2f\n",p->id,p->name,p->score);
    printf("LinkList:id=%d,  name:%s,  score=%.2f\n",q->id,q->name,q->score);
    
    free(q);
    q=NULL;
    printf("LNode:id=%d,  name:%s,  score=%.2f\n",p->id,p->name,p->score);
    printf("LinkList:id=%d,  name:%s,  score=%.2f\n",q->id,q->name,q->score);
}

/*编译结果：
00输入
0 aa 0
11输入
1 bb 11
LNode:id=0,  name:aa,  score=0.00
LinkList:id=1,  name:bb,  score=11.00

LNode:id=0,  name:aa,  score=0.00
段错误 (核心已转储)

*/
/*总结：
*LinkList 为 LNode 类型的指针
LNode *p  || LinkList p

包含#include
malloc函数：动态申请的空间，函数返回值均为void *类型，函数返回值： 成功：返回开辟好的空间首地址。失败：返回NULL
free函数：free函数释放，然后释放后得空间记得指向为空，否则会出现野指针。
*/

/*数组冒泡&&链表冒泡*/

#include 
#include 
typedef struct LNode{
    int data;
    struct LNode *next;
}LNode,*LinkList;

void Buff_Fun(int *buff,int num)
{
    int i,j;
    for(i=0;ibuff[j+1])
            {
                int temp;
                temp=buff[j];
                buff[j]=buff[j+1];
                buff[j+1]=temp;
            }
        }
    }
    printf("数组冒泡：");
    for(i=0;idata=buff[i];
            q=List;
        }
        else
        {
            LinkList p=(LinkList )malloc(sizeof(LNode));
            q->next=p;
            p->data=buff[i];
            q=p;
        }
            
    }
    q->next=NULL;
    return List;
}
// 链表冒泡排序
LinkList bubbleSort(LinkList head) {
    int swapped;
    LinkList ptr1;
    LinkList lptr = NULL;

    // 如果链表为空，直接返回
    if (head == NULL) {
        return 0;
    }

    do {
        swapped = 0;
        ptr1 = head;

        while (ptr1->next != lptr) {
            if (ptr1->data > ptr1->next->data) {
                // 交换节点数据
                int temp = ptr1->data;
                ptr1->data = ptr1->next->data;
                ptr1->next->data = temp;
                swapped = 1;
            }
            ptr1 = ptr1->next;
        }
        lptr = ptr1;
    } while (swapped);
    return head;
}
void List_Fun(int *buff1,int num)
{
    //链表创建
    int n=0,i,j,temp;
    LinkList List=CreatList(buff1,num);
    LinkList p=List;
    bubbleSort(List);
    printf("链表冒泡：");
    while(p!=0)
    {    
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}
int main()
{
    int num=5;
    int buff0[5]={12,2,23,3,24};
    int buff1[5]={12,2,23,3,24};
    Buff_Fun(buff0,num);
    
    List_Fun(buff1,num);
    
    
}

/*编译结果：
数组冒泡：2 3 12 23 24 
链表冒泡：2 3 12 23 24 
*/