链表之单链表

链表表示方法

方法1：
结构体：
主函数中：
调用函数中：

---

方法2：（这里用的是栈的存储方式，但同样适用于链表）
结构体：
主函数中：
调用函数中：

---

方法3：
结构体：
主函数中：

调用函数中：
（这里的Status为 typedef int Status）

---

单链表代码

#include<stdio.h>
#include<stdlib.h>
struct student
{
    int num;
    float score;
    struct student *next;
};
int n;

struct student *creat()
{
    struct student *head;
    struct student *p1, *p2;
    n = 0;
    p1 = p2 = (struct student*)malloc(sizeof(struct student));
    scanf("%d%f", &p1->num, &p1->score);
    head = NULL;
    while (p1->num != 0)
    {
        n = n + 1;
        if (n == 1)
        {
            head = p1;
        }
        else
        {
            p2->next = p1;
        }
        p2 = p1;
        p1 = (struct student*)malloc(sizeof(struct student));
        scanf("%d%f", &p1->num, &p1->score);
    }
    p2->next = NULL;
    return head;
}


struct student *insert(struct student *head, struct student *stu)
{
    struct student *p0, *p1, *p2;
    p1 = head;
    p0 = stu;
    if (head == NULL)
    {
        head = p0;
        p0->next = NULL;
    }
    else
    {
        while ((p0->num > p1->num) && (p1->next != NULL))
        {
            p2 = p1;
            p1 = p1->next;
        }
        if (p0->num <= p1->num)
        {
            if (head == p1)
            {
                head = p0;
            }
            else
            {
                p2->next = p0;
            }
            p0->next = p1;
        }
        else
        {
            p1->next = p0;
            p0->next = NULL;
        }
        n = n + 1;
        return head;
    }
}


struct student *del(struct student *head, int num)
{
    struct student *p1, *p2;
    if (head == NULL)
    {
        printf("\nlist null\n");
        return head;
    }
    p1 = head;
    while (num != p1->num && p1->next != NULL)
    {
        p2 = p1;
        p1 = p1->next;
    }
    if (num == p1->num)
    {
        if (p1 == head)
        {
            head = p1->next;
        }
        else
        {
            p2->next = p1->next;
        }
        n = n - 1;
    }
    else
    {
        printf("%d not been found!\n",num);
    }
    return head;
}


void print(struct student *head)
{
    struct student *p;
    puts("Now these %d records are:\n", n);
    p = head;
    if (head != NULL)
    {
        do
        {
            printf("%d%5.1f\n", p->num, p->score);
            p = p->next;
        } while (p != NULL);
    }
}

int main(void)
{
    struct student *head, *stu;
    int del_num;
    int i;

    printf("input records(when num==0&&score==0,OVAR!):\n");
    head = creat();
    print(head);


    printf("input the deleted number:(when num==0,OVAR!)\n");
    scanf("%d", &del_num);
    while (del_num != 0)
    {
        head = del(head, del_num);
        print(head);
        printf("input the delted number!\n");
        scanf("%d", &del_num);
    }

    printf("input the insert number(when num==0&&score==0,OVAR!):\n");
    stu = (struct student *)malloc(sizeof(struct student));
    scanf("%d%f", &stu->num, &stu->score);
    while (stu->num!=0)
    {
        head = insert(head, stu);
        print(head);
        printf("input the insert number:\n");
        stu = (struct student *)malloc(sizeof(struct student));
        scanf("%d%f", &stu->num, &stu->score);
    }


    getch();
    return  0;
}

测试结果：

---

单链表代码2

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
//定义链表节点
typedef int bool;

typedef struct Node
{
    int data;  //数据域
    struct Node * pNext; //指针域
}NODE, *PNODE;  //NODE等价于struct Node, PNODE等价于struct Node *
//函数声明
PNODE createLinkList(void);    //创建链表的函数
void traverseLinkList(PNODE pHead);   //遍历链表的函数
bool isEmpty(PNODE pHead);    //判断链表是否为空的函数
int getLength(PNODE pHead);    //获取链表长度的函数
bool insertElement(PNODE pHead, int pos, int val); //向链表中插入元素的函数，三个参数依次为链表头结点、要插入元素的位置和要插入元素的值
bool deleteElement(PNODE pHead, int pos, int * pVal); //从链表中删除元素的函数，三个参数依次为链表头结点、要删除的元素的位置和删除的元素的值
void sort(PNODE pHead);     //对链表中的元素进行排序的函数(基于冒泡排序)
int main(void)
{
    int val;   //用于保存删除的元素
    PNODE pHead = NULL;  //PNODE等价于struct Node *
    pHead = createLinkList(); //创建一个非循环单链表，并将该链表的头结点地址赋给pHead
    traverseLinkList(pHead); //调用遍历链表的函数
    if (isEmpty(pHead))
        printf("链表为空！\n");
    else
        printf("链表不为空！\n");
    printf("链表的长度为：%d\n", getLength(pHead));
    //调用冒泡排序函数
    sort(pHead);
    //重新遍历
    traverseLinkList(pHead);
    //向链表中指定位置处插入一个元素
    int m,i;
    printf("要插入的元素:");
    scanf("%d", &m);
    printf("要插入的位置:");
    scanf("%d", &i);
    if (insertElement(pHead, i, m))
        printf("插入成功!插入的元素为：%d\n", m);
    else
        printf("插入失败!\n");
    //重新遍历链表
    traverseLinkList(pHead);
    //删除元素测试
    int n;
    printf("要删除第几个元素?");
    scanf("%d", &n);
    if (deleteElement(pHead, n, &val))
        printf("元素删除成功!删除的元素是：%d\n", val);
    else
        printf("元素删除失败!\n");
    traverseLinkList(pHead);
    system("pause");
    return 0;
}

PNODE createLinkList(void)
{
    int length; //有效结点的长度
    int i;
    int value; //用来存放用户输入的结点的值
    //创建了一个不存放有效数据的头结点
    PNODE pHead = (PNODE)malloc(sizeof(NODE));
    if (NULL == pHead)
    {
        printf("内存分配失败，程序退出！\n");
        exit(-1);
    }
    PNODE pTail = pHead; //pTail始终指向尾结点
    pTail->pNext = NULL; //清空指针域
    printf("请输入您想要创建链表结点的个数：len = ");
    scanf("%d", &length);
    for (i = 0; i<length; i++)
    {
        printf("请输入第%d个结点的值：", i + 1);
        scanf("%d", &value);
        PNODE pNew = (PNODE)malloc(sizeof(NODE));
        if (NULL == pHead)
        {
            printf("内存分配失败，程序退出！\n");
            exit(-1);
        }
        pNew->data = value; //向新结点中放入值
        pTail->pNext = pNew; //将尾结点指向新结点
        pNew->pNext = NULL; //将新结点的指针域清空
        pTail = pNew;  //将新结点赋给pTail,使pTail始终指向为尾结点
    }
    return pHead;
}

void traverseLinkList(PNODE pHead)
{
    PNODE p = pHead->pNext;
    while (NULL != p)
    {
        printf("%d ", p->data);
        p = p->pNext;
    }
    printf("\n");
    return;
}

bool isEmpty(PNODE pHead)
{
    if (NULL == pHead->pNext)
        return 1;
    else
        return 0;
}

int getLength(PNODE pHead)
{
    PNODE p = pHead->pNext;  //指向首节点
    int len = 0;   //记录链表长度的变量
    while (NULL != p)
    {
        len++;
        p = p->pNext;  //p指向下一结点
    }
    return len;
}

void sort(PNODE pHead)
{
    int len = getLength(pHead); //获取链表长度  
    int i, j, t;   //用于交换元素值的中间变量
    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)
            {
                t = p->data;
                p->data = q->data;
                q->data = t;
            }
        }
    }
    return;
}

bool insertElement(PNODE pHead, int pos, int val)
{
    int i = 0;
    PNODE p = pHead;
    //判断p是否为空并且使p最终指向pos位置的结点
    while (NULL != p && i<pos - 1)
    {
        p = p->pNext;
        i++;
    }
    if (NULL == p || i>pos - 1)
        return 0;
    //创建一个新结点
    PNODE pNew = (PNODE)malloc(sizeof(NODE));
    if (NULL == pNew)
    {
        printf("内存分配失败，程序退出!\n");
        exit(-1);
    }
    pNew->data = val;
    //定义一个临时结点，指向当前p的下一结点
    PNODE q = p->pNext;
    //将p指向新结点
    p->pNext = pNew;
    //将q指向之前p指向的结点
    pNew->pNext = q;
    return 1;
}

bool deleteElement(PNODE pHead, int pos, int * pVal)
{
    int i = 0;
    PNODE p = pHead;
    //判断p是否为空并且使p最终指向pos结点
    while (NULL != p->pNext && i<pos - 1)
    {
        p = p->pNext;
        i++;
    }
    if (NULL == p->pNext || i>pos - 1)
        return 0;
    //保存要删除的结点
    *pVal = p->pNext->data;
    //删除p后面的结点
    PNODE q = p->pNext;
    p->pNext = p->pNext->pNext;
    free(q);
    q = NULL;
    return 1;
}

测试结果：