[数据结构与算法] 单链表的简单demo

Vc6之下编译通过。。

 

/*******************************************************
* @: Project:    单链表数据结构演示
* @: File:        link_list.h
* @: Function： 提供单链表操作的数据结构定义及方法声明
* @: History:    2013-10-01 22:37:05
* @: Author:    Alimy
*******************************************************/
/*******************************************************
* @:头文件包含
*******************************************************/

#ifndef __LINK_LIST_H__
#define __LINK_LIST_H__
/*******************************************
* @: 数据结构定义&一些宏
********************************************/
#define ElemType   signed short    int            // 此例子中的数据为有符号短整形，在VC6 中占据16bits
#define StatusType    int        //操作状态为int类型
#define OK    (StatusType)1
#define ERROR (StatusType)0

typedef struct LNode{
    ElemType m_data;              // 数据域
    struct LNode *p_next;     // 指针域
} LNode, *pLinkList;

//typedef struct LHead{ //头结点,其实和 LNode的内存结构相似，
//    int ElemNumber;  //数据域，可以存储当前线性表的长度，也可以什么也不存储
//    struct LNode *p_FirstNode; //指针域指向线性表的第一个元素
//}LHead, *pLHead;

#define DATA_FIELD    0//定义是否让头结点的数据域存储表长信息 1为存储(头结点模式)，0为不存储(非头结点模式)

/*******************************************
* @: 外部调用函数声明
********************************************/
extern StatusType CreateList_L(pLinkList *pL,int num);//构造num个结点的单链表
//extern StatusType _CreateList_L(pLinkList *pL,int num);
extern StatusType GetElem_L(pLinkList *pL,int idx_location, ElemType* pe); //获取单链表的元素
extern StatusType InsertElem_L(pLinkList *pL,int idx_location,ElemType e);//在单链表中插入元素
extern StatusType DeleteElem_L(pLinkList *pL,int idx_location,ElemType* pe);//在单链表中删除元素
extern void ClearList_L(pLinkList *pL);    //整表删除
extern int LocateElem_L(pLinkList *pL,ElemType e); //定位元素
extern int GetLength_L(pLinkList *pL);

extern void MergeList_L1(pLinkList *pLa,pLinkList *pLb,pLinkList *pLc);//将两个有序链表并为一个有序链表
extern void MergeList_L2(pLinkList *pLa,pLinkList *pLb,pLinkList *pLc);//将两个有序链表并为一个有序链表


extern void DisplayList_L(pLinkList *pL); //显示当前所有单链表的长度
#endif // end of __LINK_LIST_H__

 

/*******************************************************
* @: Project:    单链表数据结构演示
* @: File:        link_list.c
* @: Function： 提供单链表操作的基本函数和方法
* @: History:    2013-10-01 22:37:37
* @: Author:    Alimy
*******************************************************/

/*******************************************************
* @: 头文件包含 
*******************************************************/
#include "link_list.h"
#include <stdio.h> 
#include <conio.h>    // int getch(void);
#include <stdlib.h>  // int rand(void);  malloc(); free();
#include <time.h>    // time_t time(time_t *);

/*******************************************************
* @: （外部&内部）变量声明及定义
*******************************************************/

/*******************************************************
* @: （外部&内部）函数声明及定义
*******************************************************/
StatusType CreateList_L(pLinkList *pL,int num);//构造num个结点的单链表
StatusType GetElem_L(pLinkList *pL,int idx_location, ElemType* pe); //获取单链表的元素
StatusType InsertElem_L(pLinkList *pL,int idx_location,ElemType e);//在单链表中插入元素
StatusType DeleteElem_L(pLinkList *pL,int idx_location,ElemType* pe);//在单链表中删除元素
int LocateElem_L(pLinkList *pL,ElemType e); //定位元素
int GetLength_L(pLinkList *pL);//获得表长
void ClearList_L(pLinkList *pL);    //整表删除

void DisplayList_L(pLinkList *pL); //显示当前所有单链表的长度






/*******************************************************
* @: 内部函数具体实现
*******************************************************/

//ElemType s_data[] = {1,2,3,4,5,6,7,8,9,10,11};

/*
*@:在堆中构造一个单链表，并逆序插入num个结点(头插法)
*@:返回值 
*@:    构造成功返回OK
*@: 构造失败返回ERROR
**/
StatusType CreateList_L(pLinkList *pL,int num){//构造num个结点的单链表
    LNode*  p_Work = NULL; //工作指针
    int idx = 0;
    if(*pL!=NULL){
        printf("当前单链表已被初始化，不需要执行Create操作 \n");
        return ERROR;
    }

    *pL = (pLinkList)malloc(sizeof(LNode));
    if(*pL == NULL){
        printf("在堆中申请头结点失败 \n");
        return ERROR;        
    }
    (*pL)->m_data = 0;  // 数据域可以存储当前单链表的长度
    (*pL)->p_next = NULL;
    
    srand(time(0));
    for(idx=0;idx<num;idx++){
        p_Work = (pLinkList)malloc(sizeof(LNode)); //在堆中申请新的结点
        if(p_Work==NULL){
            printf("在堆中申请结点出现异常,构造单链表失败  \n");
            return ERROR;
        }

        //p_Work->m_data = 10*s_data[idx%10];//(rand()%(10)); //均为10以内的整数
        p_Work->m_data = (rand()%(100))+1; //晕死,每次生产的随机数怎么都一样
        p_Work->p_next = (*pL)->p_next;
        (*pL)->p_next = p_Work;          //逆序插入，第一个产生为表尾
    }

    (*pL)->m_data = num;

//    printf("构造单链表成功，单链表的当前长度为 【%d】 \n",(*pL)->m_data);
//    printf("单链表的元素值依次是 \n");
//    p_Work = (*pL);  //指向头结点
//    idx = 0;
//    while(p_Work->p_next){// p_ Work->p_next != NULL 
//        idx++;        
//        p_Work = p_Work->p_next;
//        printf("单链表的第【%d】个元素的值为【%d】\n",idx,p_Work->m_data);

//    }
    printf("构造含【%d】个元素的单链表成功，按任意键去到主菜单\n",(*pL)->m_data);
    getch();
    return OK;
}
//StatusType _CreateList_L(pLinkList *pL,int num){//构造num个结点的单链表(尾插法)
//    LNode*  p_Work = NULL;
//    LNode*  p_NewNode = NULL; //指向新申请结点
//    LNode*  p_LastNode = NULL; //指向当前单链表的最后一个结点
//    int idx = 0;
//    if(*pL!=NULL){
//        printf("当前单链表已被初始化，不需要执行Create操作 \n");
//        return ERROR;
//    }
//
//    *pL = (pLinkList)malloc(sizeof(LNode));//(建立头结点)
//    if(*pL == NULL){
//        if(*pL == NULL){
//            printf("在堆中申请头结点失败 \n");
//            return ERROR;        
//        }
//
//    }
//    (*pL)->m_data = 0;  // 数据域可以存储当前单链表的长度  
//    (*pL)->p_next = NULL;
//    p_LastNode = (*pL);
//    srand(time(0));
//    for(idx=0;idx<num;idx++){
//        p_NewNode = (LNode*)malloc(sizeof(LNode));
//        if(p_NewNode == NULL){
//            printf("在堆中申请新结点失败 \n");
//            return ERROR;
//        }
//        p_NewNode->m_data = (rand()%(10)); 
//        p_NewNode->p_next = NULL;
//        p_LastNode->p_next = p_NewNode;
//        p_LastNode = p_NewNode;
//    }
//
//    (*pL)->m_data = num;
//
//    printf("构造单链表成功，单链表的当前长度为 【%d】 \n",(*pL)->m_data);
//    printf("单链表的元素值依次是 \n");
//    
//    p_Work = (*pL);  //指向头结点
//    idx = 0;
//    while(p_Work->p_next){// p_ Work->p_next != NULL 
//        idx++;        
//        p_Work = p_Work->p_next;
//        printf("单链表的第【%d】个元素的值为【%d】\n",idx,p_Work->m_data);
//    }
//    printf("构造含【%d】个元素的单链表成功，按任意键去到主菜单",(*pL)->m_data);
//    getch();
//    return OK;
//}



/*
*@:定位pL指向的单链表的第idx_location 个元素，并将该元素的值赋值给pe指向的内存
*@:返回值 
*@:    定位数据成功返回OK
*@: 定位数据失败返回ERROR
**/
StatusType GetElem_L(pLinkList *pL,int idx_location, ElemType* pe){ //获取单链表的元素
    int idx = 0;
    LNode * p_Work = NULL; // 工作指针
    
    #if DATA_FIELD == 0
        p_Work = (*pL);  //工作指针指向头指针
        idx = 0;
        while(p_Work && idx<idx_location){  // 移动工作指针&计数判断是否有
            p_Work = p_Work->p_next;
            idx++;
            // p_Work 指向第idx个结点
        }
    
        if((!p_Work)||(idx>idx_location)){
        //    printf("索引数据有(非头结点模式)\n");
            return ERROR;
        }
    
        *pe = p_Work->m_data;
        return OK;
    #else
        //若头结点的数据域存储了单链表的表长信息
        if((idx_location>(*pL)->m_data)||(idx_location<1)){ //索引有误
        //    printf("索引数据有误(头结点模式) \n");
            return ERROR;
        }
        p_Work = (*pL);
        idx = 0;        //工作指针指向头结点，计数清零
        for(;idx<idx_location;){
            p_Work = p_Work->p_next;
            idx++;
        }
        //此时p_Work指向第idx_location个结点
        *pe = p_Work->m_data;
        return OK;
    #endif
    
}



/*
*@:在pL指向的单链表的第idx_location 个位置插入值为e的元素
*@:返回值 
*@:    插入元素成功返回OK
*@: 插入元素失败返回ERROR
*@: 时间复杂度:O(n) 但是插入一个和插入N个区别不多，单链表适合(比较顺序表)插入操作较频繁的操作

**/
StatusType InsertElem_L(pLinkList *pL,int idx_location,ElemType e){//在单链表中插入元素

    int idx = 0;
    LNode* p_Work = NULL;
    LNode* pNewNode = NULL;

    #if DATA_FIELD == 0
        // to do 2013-10-06 00:10:46
        p_Work = (*pL);        //工作指针指向头结点
        idx = 0;

        while((p_Work)&&(idx<idx_location-1)){
            idx++;
            p_Work = p_Work->p_next;
        }  
        //正常情况下，p_Work应该指向第【idx_location - 1】个元素
        if((!p_Work)||(idx>idx_location-1)){
            printf("要插入元素的索引有误，请检查后重新输入  \n");
            return ERROR;
        }
        else{
            pNewNode = (LNode *)malloc(sizeof(LNode));            
            if(!pNewNode){
                printf("在插入元素时，申请堆空间失败,插入操作元素失败 \n");
                return ERROR;
            }
            else{
                pNewNode->m_data = e;
                pNewNode->p_next = p_Work->p_next;
                p_Work->p_next = pNewNode;
                return OK;
            }


        }        
    #else
    //头结点存储了单链表的长度
        if((idx_location<1)||(idx_location>(*pL)->m_data+1)){  // 元素索引逻辑有误
            printf("要插入元素的索引有误，请检查后重新输入  \n");
            return ERROR;
        }
        else{
            p_Work = (*pL);
            idx = 0;        //工作指针指向头结点，计数清零
            for(;idx<idx_location-1;){
                p_Work = p_Work->p_next;
                idx++;
            }
            // p_Work指向第【idx_location-1】个结点
            pNewNode = (LNode *)malloc(sizeof(LNode));
            if(!pNewNode){
                printf("在插入元素时，申请堆空间失败,插入操作元素失败 \n");
                return ERROR;
            }
            else{
                pNewNode->m_data = e;
                pNewNode->p_next = p_Work->p_next;
                p_Work->p_next = pNewNode;        // s->next = p->next;  p->next = s;  
                (*pL)->m_data++;  //计数器自加
                printf("插入元素成功\n");
                return OK;
            }
        }
    #endif 
}


/*
*@:在pL指向的单链表中寻找第一个值为e的元素，将其索引返回
*@: 返回值
*         找到值为e的元素--->返回非0 索引值
*        没有找到---->    返回0
*/
int LocateElem_L(pLinkList *pL,ElemType e){ //定位元素
        int idx = 0;
        LNode * p_Work = NULL;
        if(*pL==NULL){
            printf("当前单链表未被初始化，无法执行定位操作 \n");
            return 0;
        }
        
        p_Work = (*pL);
        idx = 0;        //计数清零，工作指针指向头结点
//_Loops:
//        if(p_Work->p_next!=NULL)
//        {
//            p_Work = p_Work->next;
//            idx++;
//            if(p_Work->m_data == e)
//                return idx;
//            goto _Loops;
//        }

        while(p_Work->p_next!=NULL){
            p_Work = p_Work->p_next;
            idx++;
            if(p_Work->m_data == e){
                printf("找到单链表的第【%d】个元素的值为【%d】",idx,p_Work->m_data);
                return idx;
            }
        }
        printf("没有定位到元素");
        return 0;  // 上述没有定位到

        
}

/*
*@:删除pL指向的单链表的第idx_location 个位置的元素，并将被删除结点的数据域赋值给pe指向的内存
*@:返回值 
*@:    删除元素成功返回OK
*@: 删除元素失败返回ERROR
*@: 时间复杂度:O(n) 但是删除一个和删除N个区别不多，单链表适合(比较顺序表)删除操作较频繁的操作
**/
StatusType DeleteElem_L(pLinkList *pL,int idx_location,ElemType* pe){//在单链表中删除元素
    int idx = 0;
    LNode * p_Work = NULL;
    LNode * p_Temp = NULL;

    #if DATA_FIELD == 0
        idx = 0;
        p_Work = (*pL);  //工作指针指向头结点
        while((p_Work)&&(idx<idx_location-1)){
            idx++;
            p_Work = p_Work->p_next;
        }
    //正常情况下，p_Work应该指向第【idx_location - 1】个元素
        if((!p_Work)||(idx>idx_location-1)){
            printf("要删除位置的索引有误，请重新输入 \n");
            return ERROR;
        }
        else{
            p_Temp = p_Work->p_next;  //指向要删除的结点
            p_Work->p_next = p_Temp->p_next;//p_Work->p_next = p_Work->p_next->p_next;
            *pe = p_Temp->m_data;
            free(p_Temp);
            return OK;
        }
    #else
        if((idx_location<1)||(idx_location>(*pL)->m_data)){ // 
            printf("要删除元素位置索引有误，请检查输入 \n");
            return ERROR;
        }
        else{
            p_Work = (*pL);
            idx = 0;            //工作指针指向头结点
            for(;idx<idx_location-1;){
                p_Work = p_Work->p_next;
                idx++;
            }
            //p_Work指向第【idx_location - 1 】个结点
            p_Temp =  p_Work->p_next;
            p_Work->p_next = p_Temp->p_next;//p_Work->p_next = p_Work->p_next->p_next;
            *pe = p_Temp->m_data;
            free(p_Temp);
            (*pL)->m_data--;
            return OK;
        }
        
    #endif
}

/*
* @:获取pL指向的单链表中的元素个数
* @:返回值
*        得到长度--->返回非0长度值
*        得不到长度---->返回0
*/
int GetLength_L(pLinkList *pL){//获得表长

    int idx = 0;
    LNode * p_Work = NULL;
    if(*pL==NULL){
        printf("当前单链表未被初始化，无法获取表长\n");
        return 0;
    }
    #if DATA_FIELD == 0
        p_Work = (*pL);
        idx = 0;        //计数清零，工作指针指向头结点
        while(p_Work->p_next!=NULL){
            idx++;
            p_Work = p_Work->p_next;
        }
        printf("当前单链表共有【%d】个元素\n",idx);
        return idx;

    #else
        idx = (*pL)->m_data;
    printf("当前单链表共有【%d】个元素\n",idx);
        
        return idx;


    #endif

}
/*
*@:删除pL指向的单链表的所有结点
*/

void ClearList_L(pLinkList *pL){    //整表删除
    LNode* p_Work1 = NULL;
    LNode* p_Work2 = NULL; //工作指针
    
    if(*pL == NULL){
        printf("当前单链表未创建，无法执行整表删除操作 \n");
        return ;
    }
    else if((*pL)->p_next == NULL){
        printf("当前单链表为空表，不需要执行整表删除操作 \n");
        return;
    }
    else{
        p_Work1 = (*pL)->p_next; // 指向第一个结点(如果有的话)
        while(p_Work1!=NULL){
            p_Work2 = p_Work1;
            p_Work1 = p_Work2->p_next;//指向下一个
            free(p_Work2);
        }

    //    (*pL)->p_next = NULL;        // 头结点指向NULL
        (*pL)->m_data = 0;
        return ;
    }
}

/*
*@: 输出显示pL指向的单链表所有的元素
*/
void DisplayList_L(pLinkList *pL){ //显示当前所有单链表的长度

    int idx = 0;
    LNode* p_Work = NULL;

    if(*pL==NULL){
        printf("单链表还未构建，输不出东东 \n");
        return ;
    }

    #if DATA_FIELD == 0
        idx = 0;
        p_Work = (*pL); // 工作指针指向头结点，计数清零
        if(p_Work->p_next==NULL){
            printf("当前单链表为空表，没什么东东好显示的 \n");
            return ;
        }
        else{
            while(p_Work->p_next){ //(p_Work->p_next!=NULL)
                idx++;
                p_Work = p_Work->p_next;
                printf("单链表第【%d】个元素的值为【%d】\n",idx,p_Work->m_data);
            }
            return ;
        }
    #else
        if((*pL)->m_data == 0){
            printf("当前单链表的表长为0，没有数据元素，没有什么好打印的 \n");
            return ;
        }
        idx = 0;
        p_Work = (*pL);  // 工作指针指向头结点，计数清零
        printf("单链表数据如下:\n");
        for(;idx<(*pL)->m_data;){  //  idx < currentLength   (currentLength == (*pL)->m_data  or  currentLength == GetLength_L )
            idx++;
            p_Work = p_Work->p_next;
            printf("单链表第【%d】个元素的值为【%d】\n",idx,p_Work->m_data);
        }
        return ;
    #endif

}




//演示程序中没有用到的程序

void MergeList_L1(pLinkList *pLa,pLinkList *pLb,pLinkList *pLc);//归并两个单链表
/*
*@:归并,已知pLa和pLb指向的单链表的元素都按非递减排列
*    将La 和Lb中的元素归并到pLc指向的单链表中
*/
void MergeList_L1(pLinkList *pLa,pLinkList *pLb,pLinkList *pLc){ // 按顺序表的方法新建结点归并到pLc,形成一个新的表，对原来的那两个单链表没有损伤
    LNode * p_WorkLa = NULL;
    LNode * p_WorkLb = NULL;
    int Lc_len = 0;
    *pLc = (LNode *)malloc(sizeof(LNode)); //*pLc进来是是未被初始化的，即(*pLc) == NULL 
    (*pLc)->m_data = 0;
    (*pLc)->p_next = NULL;  // 将pLc指向空表
    

    p_WorkLa = (*pLa)->p_next;
    p_WorkLb = (*pLb)->p_next;    // 初始化时都指向第一个结点(如果有第一个的话)

    while((p_WorkLa!=NULL)&&(p_WorkLb!=NULL)){
        Lc_len++; //一定有可以插入的元素
        if(p_WorkLa->m_data>=p_WorkLb->m_data){
            InsertElem_L(pLc,Lc_len,p_WorkLb->m_data);
            p_WorkLb = p_WorkLb->p_next;    
        }
        else{
            InsertElem_L(pLc,Lc_len,p_WorkLa->m_data);
            p_WorkLa = p_WorkLa->p_next;
        }
    }

    while(p_WorkLa!=NULL){
        Lc_len++;
        InsertElem_L(pLc,Lc_len,p_WorkLa->m_data);
        p_WorkLa = p_WorkLa->p_next;
    }

    while(p_WorkLb!=NULL){
        Lc_len++;
        InsertElem_L(pLc,Lc_len,p_WorkLb->m_data);
        p_WorkLb = p_WorkLb->p_next;
    }
}


void MergeList_L2(pLinkList *pLa,pLinkList *pLb,pLinkList *pLc){//不新建结点，就用链表把la和lb中的元素用指针连接起来也成为lc的结点
    LNode* p_la = NULL;
    LNode* p_lb = NULL;
    LNode* p_lc = NULL;

    p_la = (*pLa)->p_next;
    p_lb = (*pLc)->p_next;    // 都指向第一个结点

    pLc = p_lc = p_la; //用La的头结点作为Lc的头结点

    while((p_la!=NULL)&&(p_lb!=NULL)){
        if(p_la->m_data <= p_lb->m_data){
            p_lc->p_next = p_la;
            p_lc = p_la;    // 工作指针移动
            p_la = p_la->p_next;
        }
        else{
            pLc->p_next = p_lb;
            p_lc = p_lb;
            p_lb = p_lb->p_next;
        }
    }

    if(p_la != NULL){
        p_lc->p_next = p_la;
    }

    if(p_lb != NULL){
        p_lc->p_next = p_lb;
    }

    free(*(pLb));//释放Lb结点
    (*pLb)->p_next = NULL;//Lb被直接置为空表了!
        
}

 

 

/*******************************************************
* @: Project:    单链表数据结构演示
* @: File:        main.c
* @: Function： 单链表demo主程序
* @: History:    2013-10-01 22:36:03
* @: Author:    Alimy
*******************************************************/

/*******************************************************
* @: 头文件包含
*******************************************************/
#include "link_list.h"
#include <stdio.h>
#include <conio.h>   
#include <stdlib.h> 


/*******************************************************
* @:(外部&内部)变量声明及定义
*******************************************************/

/*******************************************************
* @: （外部&内部）函数声明及定义
*******************************************************/
void printmenu(void);


/*******************************************************
* @: 主函数
*******************************************************/
int main(){
    pLinkList   LinkList_Display = NULL;
    unsigned char keyValue = 0;
    int idx = 0;
    ElemType e = 0;
    if(OK!=CreateList_L(&LinkList_Display,5))
        goto _end;
    
    while(1){
        system("cls");
        printmenu();
        fflush(stdin);
        scanf("%c",&keyValue);
        fflush(stdin);
        switch(keyValue){
            case 'a':
                printf("请输入你要插入的位置索引及要插入的数据\n");
                scanf("%d%d",&idx,&e);
                printf("你要插入数据的位置是 【%d】,要插入的数据是【%d】\n",idx,e);
                InsertElem_L(&LinkList_Display,idx,e);
                printf("按任意键返回主菜单\n"); 
                getch();
                break;
            
            case 'b':
                printf("请输入你要删除单链表中的元素的索引\n");
                scanf("%d",&idx);
                printf("你要删除数据的位置是 【%d】\n",idx);
                if(OK==DeleteElem_L(&LinkList_Display,idx,&e)){
                    printf("删除元素成功,被删除的元素值为 %d \n",e);
                }
                printf("按任意键返回主菜单\n"); 
                getch();
                break;
            case 'c':
                printf("请输入你要得到单链表中的元素的索引\n");
                scanf("%d",&idx);
                if(OK!=GetElem_L(&LinkList_Display,idx,&e)){
                    printf("获取元素失败,请检查相关输入是否符合操作条件\n");
                    }
                else{
                    printf("获取到的元素是 %d \n",e);
                    }
                printf("按任意键返回主菜单\n"); 
                getch();
                break;
            case 'd':
                printf("请输入你要定位单链表中的元素值\n");
                scanf("%d",&e);
                LocateElem_L(&LinkList_Display,e);
                printf("按任意键返回主菜单\n"); 
                getch();
                break;
            case 'e':
                idx = GetLength_L(&LinkList_Display);
                if(LinkList_Display->p_next!=NULL){
                    printf("当前表长为【%d】 \n", idx);
                }
                printf("按任意键返回主菜单\n"); 
                getch();
                break;
            case 'f':
                ClearList_L(&LinkList_Display);
                printf("清除单链表完成,按任意键返回主菜单\n"); 
                getch();
                break;
            case 'g':
                DisplayList_L(&LinkList_Display);
                printf("按任意键返回主菜单\n"); 
                getch();
                break;
            case 'h':
                goto _end;
                break;
            default:
                printf("你的输入环节有误,清重新输入 \n");
                printf("按任意键返回主菜单\n"); 
                getch();
                break;
        }
    }

    

_end:
    ClearList_L(&LinkList_Display);      // 释放堆空间
    if(LinkList_Display!=NULL)
        free(LinkList_Display); //释放头结点
/*

错误代码 :
    while(LinkList_Display!=NULL)
        free(LinkList_Display);
        
//刚刚才知道 free(p)之后p还是原来的数，不会变成NULL
研究了一下 p自身虽然是指针，但不能通过指针的值并不能改变自身的值，所以说传地址能改变原元素的值是有条件的
再者，传值就一定改变不了原元素的 值么

//另外一个测试代码，VC6下测试结果符合预期，其他编译器未经测试
// test -- start
#include <stdio.h>
void changedata(long int pointer){
    *((int *)pointer) = 100;
    return ;

}
int main(void){
    int temp = 1000;
    long    int p = (long int)(&temp);  // 在VC6中long int为四个字长，等于指针长度
    printf("temp = %d \n",temp);
    changedata(p);
    printf("temp = %d \n",temp);
    return 1;
}
// test--end
传值还是传址不能被形式表象所迷惑。
*/
    getch();
    return 0;    

}


/*
*@: 打印演示主菜单
*@:返回值(无)
*/
void printmenu(void){
    printf("  【主菜单】: 请输入数据相应对应的操作\n");
    printf("【a】: 在单链表中插入元素\n");
    printf("【b】: 在单链表中删除元素\n");
    printf("【c】: 在单链表中得到元素\n");
    printf("【d】: 在单链表中定位元素\n");
    printf("【e】: 获取当前单链表的表长\n");
    printf("【f】: 清除单链表,整表删除\n");
    printf("【g】: 打印当前单链表的所有数据\n");
    printf("【h】: 退出当前程序\n");
    printf(" 您需要执行的操作项是:  ");
}



/*

单链表结构与顺序表存储结构的比较
    1:存储分配方式
        顺序表：申请连续块空间
        单链表：链式申请，存储单元任意
    2：时间性能
        查找：
            顺序表:O(1)
            单链表:O(n)
        删除&插入:
            顺序表：O(n)
            单链表：第一次为O(n),后续为O(1)
    3：空间性能
        顺序表：
            需要预分配，分配大了造成浪费;分配小了,容易造成溢出
        单链表：
            只要    有，随时可以用
            
            
若线性表需要频繁的查找，很少进行插入&删除操作，宜采用顺序存储结构
反之可以采用链式存储结构


例子：
游戏开发中，对于用户注册注册的个人信息，只读取居多，宜采用顺序存储结构
游戏中的武器或者装备列表，增加删除操作更多，宜采用链式存储结构


当线性表中的元素个数变化大或者对应用不了解的情况下，最好采用单链表结构，不必考虑存储空间的大小问题。
若评估知道规模大致长度，可以用顺序表。。

总之：综合各种条件考虑！
*/

 

（老实说，我对单链表的头结点有点好奇，

我的想法是为头结点单独管理，然后让头结点的数据域来管理单链表的长度。。。这样在插入&删除等操作中，直接就可以用头结点的数据域来判断是否能完成插入&删除等操作了。。

typedef struct LHead{ //头结点,其实和 LNode的内存结构相似，
 int LinkListLength; //数据域，可以存储当前线性表的长度，也可以什么也不存储
 struct LNode *p_FirstNode; //指针域指向线性表的第一个元素
}LHead, *pLHead;

）

 

额。静态链表&（循环链表&双向链表）就直接跳过了，不写demo了。。

静态链表不是在拥有指针机制的其他高级语言使用链表的机制。

 

循环链表&双向链表和单链表的实现类似。