正文之前

睡前谢谢代码放松精神，数学实在太磨人了。明天继续怼多元微分学！太难了！！沃日，都还给老师了！

正文

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE  5
//注：定义结构体及其指针
typedef struct List   
{
    int Data[MAXSIZE];
    int  Last;
} List, *PtrL;

 typedef struct Stack
{
    int Data[MAXSIZE];
    int  Top;
} Stack,*PtrS;




PtrS InitList()
{
    PtrS ptrs;
    
    //注：不知道是MAXSIZE 还是不要，不过乘上总归是没错的！
    ptrs=(PtrS)malloc(sizeof(Stack));
    //注：初始栈顶指针指向0，第一次复制就有了Data[0]=Data[Last]，方便复用
    ptrs->Top=-1;
    //注：讲初始化后的堆栈传回
    return ptrs;
}

void Push(PtrS ptrs,int data)
{
    if (ptrs->Top==MAXSIZE-1)
    {
        printf("Full Full!!\n" );
    }
    else
    {
        ptrs->Data[++(ptrs->Top)]=data;
    }
}


int Pop(PtrS ptrs)
{
    if (ptrs->Top==-1)
    {
        printf("Empty  Empty!!\n" );
        printf("Go Away 我被掏空啦！\n");
        return 0;
    }
    else
    {
        ptrs->Top--;
        return  ptrs->Data[(ptrs->Top+1)];
        
    }
}

void ShowStack(PtrS ptrs)
{
    int i,num;
    for (i=ptrs->Top; i >= 0; --i)
    {
        num=Pop(ptrs);
        printf("%d is poped\n",num);
    }
}
//注：初始化线性表函数，传入一个表头，之后申请内存，使之成为静态变量

PtrL InitList(PtrL ptrl) 
{
    List *ptrL;
    
//注：不知道是MAXSIZE 还是不要，不过乘上总归是没错的！
    ptrL=(List *)malloc(MAXSIZE*sizeof(List));  
//注：初始尾指针指向-1，第一次复制就有了Data[0]=Data[Last]，方便复用
    ptrL->Last=-1; 
//注：讲初始化后的线性表传回
      return ptrL;
}



//注：插入数值函数，先预判需要插入的地方是否合法
void Insert(PtrL ptrL,int location,int item)
{
    if ( ptrL->Last == MAXSIZE-1 )
    {        /* 表空间已满，不能插入*/
        printf("表空间已满，不能插入");
        return;
    }
    if ( location< 0 || location > ptrL->Last+2)
    {
        /*检查插入位置的合法性*/
        printf("位置不合法");
    }   
    
//注：在插入位置之后的所有元素统统向后移位，到了location位置之后，传入给定值
    int i=ptrL->Last;
    for (i=ptrL->Last; i >= location; --i)
    {
        ptrL->Data[i+1]=ptrL->Data[i];
    }
    ptrL->Data[location]=item;
    
//注：尾指针要加一，确保一直指向最后的一个数值
    ptrL->Last+=1;
}

//注：遍历函数，简单易懂，只是一开始忘了尾指针在第一个数值传入的时候等于0，后来想起来了。
void ShowList(PtrL ptrl)
{
    for (int i = 0; i < ptrl->Last+1; i++)
    {
        printf("%d\n 加油啊！💪\n",ptrl->Data[i]);
    }
}


int main()
{

    PtrS ptrs;
    ptrs=InitList();
    Push(ptrs,100);

    PtrL ptrl;
    ptrl=InitList(ptrl);
    Insert(ptrl,0,5);
    Insert(ptrl,1,4);
    Insert(ptrl,2,89);
    Insert(ptrl,3,100);
    PtrL p=ptrl;
    int output;
    for (int i = 0; i < p->Last+1; i++)
    {
        output=p->Data[i];
        printf("%d\n 加油啊！💪\n",output);
        Push(ptrs,output);
    }
    printf("\n--------------\n| \tfuck  \t|\n--------------\n" );
    ShowStack(ptrs);
    return 0;
}

阿西吧，随便结合了下堆栈和线性表的特性，实现了线性表的反向输出！Yeah~~

运行结果：

HustWolf-MacBook-Air:~ zhangzhaobo$ /Users/zhangzhaobo/program/C/Reverse_Output_Link_List ; exit;
5
 加油啊！💪
4
 加油啊！💪
89
 加油啊！💪
100
 加油啊！💪

--------------
|   fuck    |
--------------
100 is poped
89 is poped
4 is poped
5 is poped
100 is poped
logout
Saving session...
...copying shared history...
...saving history...truncating history files...
...completed.

[进程已完成]

正文之后

这就去睡了！嘿嘿嘿。昨晚开始心情不错，所以现在还是可以飘飘然的学习，不行 ，要抓紧了！明天白天杜绝美色诱惑！！！晚间再来Happy~~~ 走你~~~