（C）单链表

老师版

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

// 定于Node数据类型
struct Node
{
    int data;                     // 数据域
    struct Node *next;            // 指针域
};

// 创建一个单链表，并把head节点返回；
struct Node* createLinkList(void);
struct Node* createLinkList(void)
{
    struct Node *head = NULL;
    struct Node *tail = NULL;
    struct Node *temp = NULL;
    
    int data;
    
    scanf("%d",&data);
    // data 不等于0
    while (data)
    {
        // malloc 函数申请内存
        temp = (struct Node *)malloc(sizeof(struct Node));
        temp->data = data;
        temp->next = NULL;
        
        if (head == NULL)
        {
            head = temp;
            tail = temp;
        }
        else
        {
            tail->next = temp;
            tail = temp;
        }
        
        scanf("%d",&data);
    }
    
    
    return  head;
}

// 输出链表元素
void printLinkList(struct Node *head);
void printLinkList(struct Node *head)
{
    struct Node *p = head;
    if (p == NULL)
    {
        return;
    }
    else
    {
        while (p)
        {
            printf("%d-》",p->data);
            // 指针重定向
            p = p->next;
        }
    }
}

//  计算链表的长度
int count(struct Node *head);
int count(struct Node *head)
{
    int count = 0;
    struct Node *p = NULL;
    p = head;
    while (p)
    {
        count++;
        p = p->next;
    }
    
    return count;
}


int getNode(struct Node *head,int pos);
int getNode(struct Node *head,int pos)
{
    if (pos > count(head))
    {
        return 0;
    }
    
    struct Node *p = head;
    for (int i = 1; i < pos; i++)
    {
        p = p->next;
    }
    
    return p->data;
}

void insertIntoHead(struct Node **h,int value);
void insertIntoHead(struct Node **h,int value)
{
    struct Node *temp = NULL;
    temp = (struct Node *)malloc(sizeof(struct Node));
    temp->data = value;
    temp->next = NULL;
    
    if (h == NULL)
    {
        *h = temp;
    }
    else
    {
        temp->next = *h;
        *h = temp;
    }
}


//2、把单链表中第pos个结点的值修改为x的值，若修改成功返回１，否则返回０
int modifyNode(struct Node *head,int pos,int x);
int modifyNode(struct Node *head,int pos,int x)
{
    // 如果链表为空，或者pos 超出链表长度
    if (head == NULL || pos > count(head))
    {
        return 0;
    }
    
    struct Node *p = NULL;
    p = head;
    for (int i = 1; i < pos; i++)
    {
        p = p->next;
    }
    
    p->data = x;
    return 1;
}

void insertIntoTail(struct Node **head,int value);
void insertIntoTail(struct Node **head,int value)
{
    struct Node *tmp = NULL;
    tmp = malloc(sizeof(struct Node));
    tmp->data = value;
    tmp->next = NULL;
    if (*head == NULL)
    {
        *head = tmp;
    }
    else
    {
        struct Node *p;
        // 定位最后一个节点
        p = *head;
        while (p->next)
        {
            p = p->next;
        }
        // 将申请的tmp加到链表后面
        p->next = tmp;
    }
}

int insertInto(struct Node **head,int pos,int value);
int insertInto(struct Node **head,int pos,int value)
{
    if (*head == NULL)
    {
        // 在第一个位置添加一个节点
        insertIntoHead(head, value);
        return 1;
    }
    if (pos > count(*head))
    {
        // 在最后一个位置添加一个节点
        insertIntoTail(head, value);
        return 1;
    }
    // 申请一个节点
    struct Node *tmp;
    tmp = malloc(sizeof(struct Node));
    tmp->data = value;
    tmp->next = NULL;
    if (tmp==NULL)//tmp 申请内存失败
    {
        return 0;
    }
    else
    {
        // 声明一个辅助指针
        struct Node *p;
        p = *head;
        // 定位辅助指针，指向pos位置前一个节点
        for (int i = 1; i<pos-1; i++)
        {
            p = p->next;
        }
        tmp->next = p->next;
        p->next = tmp;
        return 1;
    }
}


void insertIntoSortedList(struct Node **head,int value);
void insertIntoSortedList(struct Node **head,int value)
{
    // 如果是链表为空，在第一个位置添加
    if (*head == NULL)
    {
        insertIntoHead(head, value);
        return;
    }
    
    // 记录要添加元素的位置
    int pos = 1;
    struct Node *p = NULL;
    p = *head;
    while (p)
    {
        if (p->data < value)
        {
            pos++;
            p = p->next;
        }
        else
        {
            // 跳出循环
            break;
        }
    }
    
    insertInto(head, pos, value);
}

int deleteFirstNode(struct Node **head);
int deleteFirstNode(struct Node **head)
{
    if (*head == NULL)
    {
        return 0;
    }
    
    struct Node *p = NULL;
    p = *head;
    
    *head = p->next;
    int result = p->data;
    
    // 注意释放内存
    free(p);
    p = NULL;
    
    return result;
    
    
}

int deleteTailNode(struct Node **head);
int deleteTailNode(struct Node **head)
{
    if (*head == NULL)
    {
        return 0;
    }
    
    struct Node *p,*q;
    p = q = NULL;
    p = *head;
    q = p->next;
    // 通过循环定位让q指向最后一个节点，p指向q前面一个节点
    for (int i = 1; i <= count(*head)-2; i++)
    {
        p = q;
        q = q->next;
    }
    // 取最后一个节点的数据
    int result = q->data;
    
    p->next = NULL;
    free(q);
    q = NULL;
    
    return result;
}


int main(int argc, const char * argv[])
{

    struct Node *head = NULL;
    // 产生链表
    head = createLinkList();
    
    // 输出链表元素个数
    int c = count(head);
    printf("c = %d\n",c);
    
    
    //insertIntoHead(&head, 10);
    
    //modifyNode(head, 2, 10);
    
    //insertIntoTail(&head, 100);
    //insertInto(&head, 2, 100);
    
    //insertIntoSortedList(&head, 6);
    //deleteFirstNode(&head);
    int r = deleteTailNode(&head);
    printf("删除最后一个节点%d\n",r);
    
    // 输出链表
    printLinkList(head);
    
    
    /*
    // 输出第二个节点的数据域；
    c = getNode(head, 2);
    printf("\n");
    printf("c = %d\n",c);
    */
    
    return 0;
}

不才版

#include <stdio.h>

#include <stdlib.h>

struct Node
{
    int data;
    struct Node *next;
};

struct Node *creatLinkList(void)
{
    struct Node *head=NULL;
    struct Node *tail=NULL;
    struct Node *temp=NULL;
    
    int data;
    scanf("%d",&data);
    while (data)
    {
        temp=malloc(sizeof(struct Node));
        temp->data=data;
        temp->next=NULL;
        
        if(head==NULL)
            head=tail=temp;
        else
        {
            tail->next=temp;
            tail=temp;
        }
        scanf("%d",&data);
    }
    return head;
}

void printLinkList(struct Node *head)
{
    struct Node *tmp=head;
    if (tmp==NULL) {
        return;
    }
    while (tmp!=NULL) {
        printf("%d->>",tmp->data);
        tmp=tmp->next;
    }
    printf("\n");
}

int toNode(struct Node *head,int pos)
{
    int data;
    for (int i=0; i<pos; i++) {
        if ((i!=pos-1)&&(head->next==NULL))
            return 0;
        data=head->data;
        head=head->next;
    }
    return data;
    
    //链表长度可以用count(head)算出。
}

int changeData(struct Node *head,int pos,int x)
{
    for (int i=0; i<pos; i++) {
        if ((i!=pos-1)&&(head->next==NULL))
            return 0;
        if (i==pos-1) {
            head->data=x;
        }
        head=head->next;
    }
    return 1;
}

void insertNodeInHead(struct Node **head,int value)
{
    struct Node *tmp=NULL;
    tmp=(struct Node *)malloc(sizeof(struct Node));
    tmp->data=value;
    tmp->next=*head;
    *head=tmp;
}

void insertNodeInEnd(struct Node *head,int value)
{
    struct Node *tmp=NULL;
    tmp=(struct Node *)malloc(sizeof(struct Node));
    tmp->data=value;
    tmp->next=NULL;
    if (head==NULL) {
        head=tmp;
    }
    while (head->next!=NULL) {
        head=head->next;
    }
    head->next=tmp;
}

int insertData(struct Node *head,int pos,int value)
{
    struct Node *tmp=NULL;
    tmp=(struct Node *)malloc(sizeof(struct Node));
    if (tmp==NULL) {
        return 0;
    }
    tmp->data=value;
    if (pos==0) {
        return 0;
    }
    for (int i=0; i<pos; i++) {
        
        if ((i!=pos-1)&&(head->next==NULL)) {
            return 0;
        }
        if (i==pos-1) {
            tmp->next=head->next;
            head->next=tmp;
        }
        head=head->next;
    }
    return 1;
}

void insertSortData(struct Node *head,int value)
{
    struct Node *tmp=(struct Node *)malloc(sizeof(struct Node));
    tmp->data=value;
    while (head->data<tmp->data) {
        if (head->next->data>=tmp->data) {
            tmp->next=head->next;
            head->next=tmp;
            return;
        }
        if (head->next==NULL) {
            tmp->next=head->next;
            head->next=tmp;
            return;
        }
        head=head->next;
    }
    
}

int deleteHead(struct Node **pointhead)
{
    int data;
    data=(*pointhead)->data;
    struct Node *p=*pointhead;
    *pointhead=(*pointhead)->next;
    free(p);
    p=NULL;
    if (*pointhead==NULL||(*pointhead)->next==NULL) {
        return 0;
    }
    return data;
}
    
int deleteEnd(struct Node *head)
{
    struct Node *tmp=head;
    int data;
    if(head==NULL||head->next==NULL)
        return 0;
    while (tmp->next!=NULL) {
        if (tmp->next->next==NULL) {
            data=tmp->next->data;
            free(tmp->next);
            tmp->next=NULL;
            break;
        }
        tmp=tmp->next;
    }
    return data;
}

int main(int argc,const char *argv[]) 
{
    struct Node *h = creatLinkList();
    printLinkList(h);
    
    //1、返回单链表中第pos个结点中的元素，若pos超出范围，则返回０
    printf("%d\n",toNode(h,5));
    
    //2、把单链表中第pos个结点的值修改为x的值，若修改成功返回１，否则返回０
    if (changeData(h,5,5)) {
        printLinkList(h);
    }
    
    //3、向单链表的表头插入一个元素
    insertNodeInHead(&h, 0);
    printLinkList(h);
    
    //4、向单链表的末尾添加一个元素
    insertNodeInEnd(h, 50);
    printLinkList(h);
    
    //5、向单链表中第pos个结点位置插入元素为x的结点，若插入成功返回１，否则返回０
    if(insertData(h, 7, 60))
        printLinkList(h);
    
    //6、向有序单链表中插入元素x结点，使得插入后仍然有序
    insertSortData(h, 6);
    printLinkList(h);
    
    //7、从单链表中删除表头结点，并把该结点的值返回，若删除失败则返回0
    printf("%d\n",deleteHead(&h));
    printLinkList(h);
    
    //8、从单链表中删除表尾结点并返回它的值，若删除失败则返回0
    printf("%d\n",deleteEnd(h));
    printLinkList(h);
    
    return 0;
}