单链表和顺序表的实现

单链表实现：

//函数声明："linklist.h"  

#define  _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
typedef int ElemType;  
typedef struct linknode  
{  
    ElemType data;  
    struct linknode *next;  
}node;  
void judgement_memory(node * p);                //判断动态内存是否开辟成功  

node* creat_order();                //正向建立链表，尾插法  
node * creat_reverse();             //反向建立链表，头插法  

void insert(node *head, int i, ElemType x);     //在i位置上插入值为x的结点  

void delete_place(node *head, int i);           //删除i结点  
int delete_element(node *head, ElemType const x);       //删除第一个值为x的结点  
void delete_all_element(node *ret, ElemType x);       //删除所有值为x的结点  

void find_element(node *head, ElemType const x);     //寻找所有值为x的结点位置  
void find_place(node *head, int i);                  //寻找i结点上的元素  

void length_list(node *head);  

void output(node *head);                              //打印链表  

node* inits_linklist(node *head);                  //释放链表  

void sortrank(node *head);                      //对链表进行排序  

int means();  




//函数实现:"linklist.c"  

#include"linklist.h"  
void judgement_memory(node * p)     //判断开辟内存是否成功  
{  
    if (NULL == p)  
    {  
        perror("out of memory:");  
        exit(EXIT_FAILURE);  
    }  
}  

node* creat_order()                    //建立一个具有头结点单链表，顺序插入（尾插法）  
{  
    printf("开始建立：");  
    node *head, *p, *r;  
    int x = 0;  
    head = (node *)malloc(sizeof(node));             //建立头结点  
    judgement_memory(head);  
    r = head;  
    while (1)  
    {  
        scanf("%d", &x);  
        if (x != 0)                                        //以0作为链表结束标志  
        {  
            p = (node *)malloc(sizeof(node));  
            judgement_memory(p);  
            p->data = x;  
            r->next = p;  
            r = p;  
        }  
        else  
            break;  
    }  
    r->next = NULL;  
    printf("创建成功\n");  
    return head;  
}  

node * creat_reverse()           //建立一个具有头结点的单链表，逆序输入（头插法）  
{  
    printf("开始建立：");  
    node *head, *p, *r, *q;  
    int x = 0;  
    head = (node *)malloc(sizeof(node));  
    judgement_memory(head);  
    p = (node *)malloc(sizeof(node));                  //开辟最后一个结点  
    judgement_memory(p);  
    p->next = NULL;  
    scanf("%d", &x);  
    p->data = x;   
    r = head;  
    q = p;  
    r->next = q;  
    while (1)  
    {  
        scanf("%d", &x);  
        if (x!= 0)  
        {  
            p = (node *)malloc(sizeof(node));  
            judgement_memory(p);  
            p->data = x;
            r->next = p;  
            p->next = q;  
            q = p;  
        }  
        else  
            break;  
    }  
    printf("创建成功\n");  
    return head;  
}  

void insert(node *head, int i, ElemType x)                 //插入一个结点  
{  
    node *r;  
    node *s = (node *)malloc(sizeof(node));  
    judgement_memory(s);  
    s->data = x;  
        while (NULL != head&&i>1)    //要在第i个结点上插入，则先找到第i-1个结点  
        {  
            i--;  
            head = head->next;  
        }  
        if (NULL != head&&i!=0)              //判断是不是头结点和结点是否存在  
        {  
            r = head->next;  
            head->next = s;  
            s->next = r;  
            printf("插入成功\n");  
        }  
        else  
            printf("结点不存在\n");  
}  


void delete_place(node *head, int i)                 //删除链表中一个指定位置的结点  
{  
    node *p;  
    if (NULL == head)                                   
    {  
        printf("链表下溢\n");  
    }  
    else  
    {  
            while (NULL != head&&i>1)            //找到第i-1个结点  
            {  
                i--;  
                head = head->next;  
            }  
            if (NULL == head||i==0)  
                printf("没有该位置\n");  
            else  
            {  
                p = head->next;  
                head->next = p->next;  
                free(p);  
                p = NULL;  
                printf("删除成功\n");  
            }  
         }  
}  


int delete_element(node *head, ElemType const x)   //删除链表中一个指定的x元素  
{  
    node *p, *q;  
    if (head == NULL)                              //链表下溢，-1  
        return -1;  
    if (x == head->data)                           //判断第一个结点的数据是不是x  
    {  
        p = head;  
        head = head->next;                            
        free(p);  
        p = NULL;  
        return 0;  
    }  
    else  
    {  
        while (NULL != head&&head->data != x)         //在链表剩下的元素中寻找x  
        {  
            q = head;  
            head = head->next;  
        }  
        if (NULL == head)                              //没找到返回 0  
            return 0;  
        else  
        {  
            p = head;  
            q->next = p->next;  
            free(p);  
            p = NULL;  
        }  
    }  
    return 1;                                            //删除成功返回1  
}  
void delete_all_element(node *ret, ElemType x)       //根据元素删除，将这个链表里面的这个元素的结点全部删除  
{  
    int m = 0;  
    int count = 0;  
    while (1)  
    {    
     m = delete_element(ret, x);  
        if (m == 0 || m == -1)  
            break;  
        count++;  
    }  
    if (m == 0)  
    {  
        if (count == 0)  
            printf("没有此元素\n");  
        else  
            printf("删除成功\n");  
    }  
    else  
        printf("链表下溢\n");  
}  

void find_element(node *head, ElemType const x)         //通过元素查找链表中该元素的位置找到返回结点  
{  
    head = head->next;                 //head是头结点，head->next指向下一个结点  
    int count = 0;  
    int i = 0;  
    while (head)  
    {  
        count++;  
        if (head->data == x)                            //如果找到输出count  
        {  
            i++;  
            printf("元素位置：%d\n", count);  
        }  
        head = head->next;  
    }  
    if (i == 0)                         //如果没有输出count，说明没有x，所以i==0;  
        printf("查询无果\n");  
    else  
        printf("\n");  
}  

void find_place(node *head, int i)              //通过位置来查找该链表中位于此位置的元素  
{  
    head = head->next;  
    while (i>1)  
    {                               //如果要找第i个结点的元素，则要先找到第i-1个结点  
        i--;  
        head = head->next;  
        if (head->next == NULL)  
            break;  
    }  
    if (i == 1)  
        printf("结点元素：%d\n", head->data);  
    else  
        printf("查询无果\n");  
}  

void length_list(node *head)           //求链表长度  
{  
    head = head->next;  
    int count = 0;  
    while (head)  
    {  
        count++;  
        head = head->next;  
    }  
    printf("链表长度：%d\n", count);  
}  

void output(node *head)                          //打印链表  
{  
    head = head->next;                            //让头结点指向下一个结点  
    printf("输出链表：");  
    while (head != NULL)  
    {  
        printf("%d  ", head->data);  
        head = head->next;  
    }  
    printf("\n");  
}  

node* inits_linklist(node *head)    //初始化链表  
{  
    node *p,*r;  
    p = head;  
    while (p != NULL)  
    {  
        r = p;  
        p = p->next;  
        free(r);  
        r = NULL;  
    }  
    head = NULL;  
    p = NULL;  
    printf("初始化成功\n");  
    return head;  
}  

void sortrank(node *head)                                  //对链表进行排序  
{  
    node *p, *r;  
    p = head->next;  
    ElemType tmp;  
    while (p != NULL)  
     {  
        r = head->next;  
        while (r->next != NULL)  
        {  
            if ((r->data) > (r->next->data))  
            {  
                tmp = r->data;  
                r->data = r->next->data;  
                r->next->data = tmp;  
            }  
            r = r->next;  
        }  
        p = p->next;  
    }  
    printf("排序成功\n");  
}  

int means()                                     //选择方式  
{  
    int means = 0;  
    while (1)  
    {  
        printf("请选择的方式：");  
        scanf("%d", &means);  
        if (means == 1 || means == 2)  
            break;  
        else  
            printf("选择无效，请重新输入\n");  
    }  
    return means;  
}  




//函数测试：  

#include"linklist.h"  

int main()  
{  
    printf("*****************************************\n");  
    printf("*****************************************\n");  
    printf("**1.Creat_LinkList    2.Insert_Element **\n");  
    printf("**3.Find              4.Delete_Element **\n");  
    printf("**5.Length_LinkList   6.Output_LinkList**\n");  
    printf("*7.InitsLinkLinst     8.Sortrank       **\n");  
    printf("*0.Exit               *******************\n\n\n");  

    node *ret=NULL;  
    ElemType x;  
    int i=0;  
    int n = 0;  
    while (1)                                      //循环起来，直到选择0结束  
    {  
        printf("请选择功能：");  
        scanf("%d", &n);  
        if (n == 0)  
        {  
            free(ret);  
            exit(1);  
        }  
        if (n == 1 && ret == NULL)  
        {                                        //选择正序建立链表还是逆序建立链表，并且链表以0作为结束标志  
            printf("**1.creat_order  2.creat_reverse **\n");  
            if (means() == 1)  
                ret = creat_order();  
            else  
                ret = creat_reverse();  
        }  
        else if (n != 1&& ret == NULL)         //必须先建立链表，才能进行其他操作  
            printf("请建立链表\n");  
        else if (ret!=NULL&&n!=1)  
        {  
            switch (n)  
            {  
            case 2:  
                printf("请输入要插入的位置和要插入的元素\n");  
                scanf("%d", &i);  
                scanf("%d", &x);  
                insert(ret, i, x);  
                break;  
            case 3:                        //选择根据位置查找还是根据元素查找  
            {  
                 printf("**1.find_place         2.find_element **\n");  
                 if (means() == 1)  
                 {  
                     printf("请输入要查找的位置：");  
                     scanf("%d", &i);  
                     find_place(ret, i);  
                 }  
                 else  
                 {  
                    printf("请输入要查找的元素：");  
                    scanf("%d", &x);  
                    find_element(ret, x);  
                }  
             }  
                break;  
            case 4:           //选择根据位置删除还是根据元素删除
            {  
                printf("**1.delete_place     2.delete_element **\n");      
                if (means() == 1)  
                {  
                    printf("请输入要删除的位置：");  
                    scanf("%d", &i);  
                    delete_place(ret, i);  
                }  
                else                                   
                {  
                    printf("请输入要删除的元素：");  
                    scanf("%d", &x);  
                    delete_all_element(ret, x);              //根据元素删除，将这个链表里面的这个元素的结点全部删除  
                }  
            }  
                break;  
            case 5:  
                length_list(ret);  
                break;  
            case 6:                           //打印链表  
                output(ret);  
                break;  
            case 7:                           //初始化链表,将链表制为空  
                ret = inits_linklist(ret);  
                break;  
            case 8:  
                sortrank(ret);  
                break;  
            default:  
                printf("选择无效，请重新选择\n");  
                break;  
            }  
        }  

    }  
    system("pause");  
    return 0;  
}       

顺序表实现：

头文件部分("sequence.h")：  

#define _CRT_SECURE_NO_WARNINGS 1  
#include <stdio.h>  
#include<stdlib.h>  
#define MAXSIZE 20  
typedef int ElemType;  
typedef struct  
{  
    ElemType data[MAXSIZE];  
    int last;  
}SeqList;  

void creat(SeqList *L);                               //创建顺序表  

int InsertSList(SeqList  *L, int i, int x);          //在i位置插入x  

int DeleteList(SeqList  *L, int i);                 //删除i位置的元素  

int GetData(SeqList *L, int  x);                          //查找值为x的下标  

int GetLength(SeqList *L);           //求顺便长度  

int InitSList(SeqList *L);       //初始化顺序表，释放整个顺表  

void output(SeqList * L);                 //打印整个顺序表  

void reverse_list(SeqList *L);        //反转整个顺序表  

void sortrank(SeqList *L);                  //对顺序表进行排序  




//封装函数部分（"sequence.c")：  

#include"sequence.h"  
void creat(SeqList *L)                          //创建一个顺序表  
{  
    printf("请输入顺序表：\n");  
    for (int n = 0; n <= L->last; n++)  
    {  
        scanf("%d", &(L->data[n]));  
    }  
    printf("输入成功\n");  
}  

int InsertSList(SeqList  *L, int i, int x)         //将x插入到i位置上，成功返回1  
{  
    if ((i<1) || i>(L->last + 2))  
        return -1;  
    if ((L->last) == (MAXSIZE - 1))  
        return -1;  
    for (int n = L->last; n >= i - 1; n--)  
        L->data[n + 1] = L->data[n];  
    L->data[i - 1] = x;  
    L->last++;  
    return 1;  
}  

int DeleteList(SeqList  *L, int i)                     //删除i位置上的元素，成功返回1  
{  
    if ((i > L->last + 1) || (i < 1))  
        return -1;  
    if (L->last == -1)  
        return -1;  
    for (int n = i - 1; n <L->last; n++)  
    {  
        L->data[n] = L->data[n + 1];  
    }  
    L->last--;  
    return 1;  
}  

int GetData(SeqList *L, int  x)                      //查找x元素的所在的位置  
{  
    int i = 0;  
    if (L->last<0)  
        return -1;  
    while (i <= L->last)  
    {  
        if (L->data[i] == x)  
            return i + 1;  
        i++;  
    }  
    return -1;  
}  

int GetLength(SeqList *L)                           //求取表的长度  
{  
    return (L->last + 1);  
}  

int InitSList(SeqList *L)                          //初始化顺序表，将当前顺序表释放  
{  
    L->last = -1;  
    return 1;  
}  

void output(SeqList * L)                   //打印顺序表  
{  
    if (L->last==-1)  
    {  
        printf("请先创建顺序表\n");  
    }  
    else  
    {  
        for (int n = 0; n <= L->last; n++)  
            printf("%d  ", L->data[n]);  
        printf("\n");  
    }  
}  

void reverse_list(SeqList *L)  
{  
    if (L->last == -1)  
        printf("请先创建顺序表\n");  
    else  
    {  
        ElemType *left = L->data;  
        ElemType *right = left + L->last;  
        while (left<right)  
        {  
            ElemType tmp = *left;  
            *left = *right;  
            *right = tmp;  
            left++;  
            right--;  
        }  
        printf("逆序成功\n");  
    }  
}  

void sortrank(SeqList *L)                               //对顺序表进行排序  
{  
    ElemType tmp;  
    int i = 0;  
    int j = 0;  
    for (i = 0; i <= L->last; i++)  
    {  
        for (j = 0; j <(L->last - i); j++)  
        {  
            if (L->data[j]>L->data[j + 1])  
            {  
                tmp = L->data[j];  
                L->data[j] = L->data[j + 1];  
                L->data[j + 1] = tmp;  
            }  
        }  
    }  
    printf("排序成功\n");  
}  



主函数部分：  

#include"sequence.h"  

int main()  
{  
    int m = 0;  
    int n = 0;  
    int i = 0;  
    int ret=0;  
    ElemType x;  
    SeqList L;  
    L.last = -1;  
    printf("***********************************************\n");  
    printf("***********************************************\n");  
    printf("********0.exit             1.Creat*************\n");  
    printf("********2.InsertSList      3.ListDelete********\n");  
    printf("********4.FindData         5.GetLength*********\n");  
    printf("********6.InitSList        7.output************\n");  
    printf("********8.ReverseList      9.Sortrank**********\n\n\n");  
    while (1)  
    {  
        printf("请选择功能:  ");  
        scanf("%d", &n);  
        switch (n)  
        {   
         case 0:  
             exit(1);  
             break;  
         case 1:  
             while (1)  
             {  
                 printf("请输入顺序表长度：");  
                 scanf("%d", &L.last);  
                 if (L.last < 1)  
                     printf("输入无效，请重新输入\n");  
                 else  
                     break;  
             }  
             L.last = L.last - 1;  
             creat(&L);  
             break;  
         case 2:  
             printf("请输入要插入的位置：  和要插入的元素：\n");  
             scanf("%d%d", &i, &x);  
             ret = InsertSList(&L, i, x);  
             if (ret == 1)  
                 printf("插入成功\n");  
             else  
                 printf("插入失败\n");  
             break;  
         case 3:  
             printf("****1、位置删除   2、元素删除****\n");  
             printf("请选择删除方式：");  
             while (1)  
             {  
                 scanf("%d", &m);  
                 if (m==1||m==2)  
                     break;  
                 else  
                     printf("选择无效，请重新选择\n");  
             }  
             switch (m)                                     //开始执行删除的方式  
             {  
             case 1:  
             {  
                       printf("请输入要删除的位置:");  
                       scanf("%d", &i);  
                       ret = DeleteList(&L,i);  
                       break;  
             }  
             case 2:  
             {  
                       int i = 0;  
                       printf("输入要删除的元素：");  
                       scanf("%d", &x);  
                       while (1)  
                       {  
                           i = GetData(&L, x);  
                           if (i ==-1)  
                               break;  
                           ret =DeleteList(&L, i);  
                       }  
                       break;  
              }                                                        //删除结束  
             }  
                 if (ret == 1)  
                     printf("删除成功\n");  
                 else  
                     printf("删除失败\n");  
             break;  
         case 4:  
             printf("请输入要查找的元素:");  
             scanf("%d",&x);  
             ret=GetData(&L,x);  
             if (ret==-1)  
                 printf("查询无果\n");  
             else     
                 printf("查找成功:%d\n",ret);  
             break;  
         case 5:  
             ret=GetLength(&L);  
             printf("顺序表长度：%d\n", ret);  
             break;  
         case 6:  
             InitSList(&L);  
             printf("初始化成功\n");  
             break;  
         case 7:  
             printf("打印顺序表：");  
             output(&L);  
             break;  
         case 8:  
             reverse_list(&L);  
             break;  
         case 9:  
             sortrank(&L);  
             break;  
         default:  
             printf("选择无效，请重新选择\n");  
             break;  
        }  
             ret = 0;  
    }  
    system("pause");  
    return 0;  
}