單鏈表-18個基本操作代碼實現C語言

單鏈表-18個基本操作代碼實現C語言

原文地址：https://www.cnblogs.com/actanble/p/6713434.html

無更改，僅復現

 

運行后如圖，運行軟件dev-C++，系統版本win10

 

 

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


typedef int elemType;     //定義存入的數據的類型可以是 int char

typedef struct NODE{      //定義單鏈表的結點類型
    elemType element;
    struct NODE *next; 
}Node;

/*             以下是關於線性表鏈接存儲（單鏈表）操作的18種算法        */
 
/* 1.初始化線性表，即置單鏈表的表頭指針為空 */
/* 2.創建線性表，此函數輸入負數終止讀取數據*/
/* 3.打印鏈表，鏈表的遍歷*/
/* 4.清除線性表L中的所有元素，即釋放單鏈表L中所有的結點，使之成為一個空表 */
/* 5.返回單鏈表的長度 */
/* 6.檢查單鏈表是否為空，若為空則返回１，否則返回０ */
/* 7.返回單鏈表中第pos個結點中的元素，若pos超出范圍，則停止程序運行 */
/* 8.從單鏈表中查找具有給定值x的第一個元素，若查找成功則返回該結點data域的存儲地址，否則返回NULL */
/* 9.把單鏈表中第pos個結點的值修改為x的值，若修改成功返回１，否則返回０ */
/* 10.向單鏈表的表頭插入一個元素 */
/* 11.向單鏈表的末尾添加一個元素 */
/* 12.向單鏈表中第pos個結點位置插入元素為x的結點，若插入成功返回１，否則返回０ */
/* 13.向有序單鏈表中插入元素x結點，使得插入后仍然有序 */
/* 14.從單鏈表中刪除表頭結點，並把該結點的值返回，若刪除失敗則停止程序運行 */
/* 15.從單鏈表中刪除表尾結點並返回它的值，若刪除失敗則停止程序運行 */
/* 16.從單鏈表中刪除第pos個結點並返回它的值，若刪除失敗則停止程序運行 */
/* 17.從單鏈表中刪除值為x的第一個結點，若刪除成功則返回1,否則返回0 */
/* 18.交換2個元素的位置 */
/* 19.將線性表進行快速排序 */

/*************************************************************************************************/





/*1，初始化線性表，即置單鏈表的表頭為空*/
void initList(Node **pNode){
    *pNode=NULL;
    printf("inirList函數執行，初始化成功！\n");
} 

/*2，創建線性表，此函數輸入負數終止讀取數據*/
Node *creatList(Node *pHead){
    
    Node *p1,*p2;
    p1=p2=(Node *)malloc(sizeof(Node));//生成新的頭結點，p1、p2兩個頭指針指向頭結點 
    if(p1==NULL||p2==NULL){
        printf("內存分配失敗\n");
        exit(0);
    }
    memset(p1,0,sizeof(Node));
    
    scanf("%d",&p1->element);
    p1->next=NULL;
    
    while(p1->element >0){   //輸入的大於0則繼續否則停止 
        if(pHead==NULL){//空表，接入表頭    
            pHead=p1;
             } 
        else{
            p2->next=p1;
            }
            
        p2=p1;
        p1=(Node *)malloc(sizeof(Node));
        
        if(p1==NULL||p2==NULL){
            printf("內存分配失敗\n");
            exit(0);
            }
        memset(p1,0,sizeof(Node));
        scanf("%d",&p1->element);
        p1->next=NULL;
        
    }
    printf("CreatList函數執行，鏈表創建成功\n");
    return pHead;
} 
/*3,打印鏈表，鏈表的遍歷*/
void printList(Node *pHead){
    if(NULL==pHead){
        printf("PrintList函數執行，鏈表為空\n");
        }
    else{
        while(NULL!=pHead){
            printf("%d",pHead->element);
            pHead=pHead->next;
        }
        printf("\n");
    }
}

/*4，清楚線性表中的所有元素，幾釋放單鏈表中的所有節點，使表為空，null*/ 
void clearList(Node *pHead){
    
    Node *pNext;
    
    if(pHead==NULL){
        printf("clearListh函數執行，鏈表為空");
        return; 
        }
    while (pHead->next!=NULL){
        pNext=pHead->next;
        free(pHead);
        pHead=pNext;
        }
    printf("clearList函數執行，鏈表已經清除"); 
}

/*5,返回鏈表的長度*/
int sizeList(Node *pHead){
    int size=0;
    
    while(pHead!=NULL){
        size++;
        pHead=pHead->next;
        }
    printf("sizeList函數執行，鏈表的長度為%d\n",size);
    return size;
}

/*6，檢擦鏈表是否為空，若空返回1，否則返回0*/
int isEmptyList(Node *pHead){
    if(pHead==NULL){
        printf("isEmptyList函數執行，鏈表為空"); 
        return 1;
        }
    else{
        printf("isEmptyList函數執行，鏈表非空");
        return 0;
        }
}
/*7，按位置查找，返回鏈表中第post節點的數據，若post超出范圍，則停止程序運行*/
int getElement(Node *pHead,int pos){
    int i=0;
    if(pos<1){
        printf("getElemnet函數執行，pos值非法！");
        return 0; 
    }
    if(pHead==NULL){
        printf("getElemnet函數執行，鏈表為空"); 
    }
    while(pHead&&i!=pos){
        i++;
        pHead=pHead->next;
    }
    if(!pHead||i<pos){
        printf("getElement函數執行，pos值超出表的長度\n");
        return 0;
        }
    printf("getElement函數執行，位置%d中的元素位置為%d\n",pos,pHead->element);
    return 1;
    
}
/*從單一倆表中查找具有得頂值x的第一個元素，成功則返回改結點data域的存儲位置，否則返回NULL*/
elemType *getElemAddr(Node *pHead,elemType x){
    
    if(NULL==pHead){
        printf("getEleAddr函數執行，鏈表為空");
        return NULL; 
    }
    if(x<0){
        printf("getEleArdd函數執行，給定值X不合法\n");
        return NULL;
    }
    while((pHead->element!=x)&&(NULL!=pHead->next)){//判斷鏈表是否為空，並且是否存在查找的元素 
        pHead=pHead->next; 
    }
    if (pHead->element!=x){
        printf("getElemAddr函數執行，在鏈表中沒有找到x的值\n");
        return NULL;
    }
    else{
        printf("getElemAddr函數執行，元素%d的地址為0x%x\n",x,&(pHead->element));
        
    }
    return &(pHead->element);
}
/*9,修改鏈表中第pos個點x的值，修改成功返回1，否則返回0*/
int modifyElem(Node *pNode,int pos,elemType x){
    
    Node *pHead;
    pHead=pNode;
    int i=0;
    if(NULL==pHead){
        printf("modityElem函數執行，鏈表為空");
        return 0;
    }
    if(pos<1){
        printf("modityElem函數執行，pos值非法\n");
        return 0;
    }
    if(pos>i){
        printf("modityElem函數執行，pos值超過鏈表長度\n");
        return 0; 
    }
    while(pHead!=NULL){
        
        ++i;
        if(i==pos){
            break;
        }
        pHead=pHead->next;
    }
    pNode=pHead;
    pNode->element=x;
    printf("modifyElem函數執行，修改第%d點的元素為%d\n",pos,x);
    return 1;
    
}






/*10,向單鏈表的表頭插入一個元素*/
int insertHeadList(Node **pNode,elemType insertElem){
    
    Node *pInsert;
    pInsert=(Node *)malloc(sizeof(Node));
    if(pInsert==NULL)  exit(1);
    memset(pInsert,0,sizeof(Node));
    pInsert->element=insertElem;
    pInsert->next=*pNode;
    *pNode=pInsert; 
    printf("insertHeadList函數執行，向單鏈表的表頭插入元素%d成功\n",insertElem);
    return 1; 
}
/*11,向單鏈表的隊尾添加一個元素*/
int insertLastList(Node *pNode,elemType insertElem){
    
    Node *pInsert;
    Node *pHead;
    Node *pTmp;
    
    pHead=pNode;
    pTmp=pHead;
    pInsert=(Node *)malloc(sizeof(Node));
    if(pInsert==NULL)  exit(1);
    memset(pInsert,0,sizeof(Node));
    pInsert->element=insertElem;
    pInsert->next=NULL;
    while(pHead->next!=NULL){
        
        pHead=pHead->next;
    }
    pHead->next=pInsert;
    printf("insertLastList函數執行，向單鏈表的隊尾添加元素%d成功\n",insertElem);
    return 1;
}
/*12，向單鏈表中的第pos個節點插入元素為x的節點，成功返回1，否則后返回0*/
int isAddPos(Node *pNode,int pos,elemType x){
    
    Node *pHead;
    pHead=pNode;
    Node *pTmp;
    int i=0;
    
    if(NULL==pHead){
        printf("AddPos函數執行，鏈表為空");
        return 0; 
    }
    if(pos<1){
        printf("AddPos函數執行，pos值非法");
        return 0;
    }
    while(pHead!=NULL){
        ++i;
        if(i==pos){
            break;
        }
        pHead=pHead->next;
    }
    if(i<pos){
        printf("AddPos函數執行，pos值超出鏈表的長度");
        return 0; 
    }
    pTmp=(Node *)malloc(sizeof(Node));
    if(pTmp==NULL) exit(1);
    memset(pTmp,0,sizeof(Node));
    pTmp->next=pHead->next;
    pHead->next=pTmp;
    pTmp->element=x;
    
    printf("AddPos函數執行成功，像結點%d后插入數值%d\n",pos,x);
    return 1;
}
/*13,向單鏈表插入元素x節點，是的插入后仍有序*/
int OrrderList(Node *pNode,elemType x){
    //注意如果此數值要排到行尾要修改本代碼
    Node *pHead=pNode;
    pHead=pNode;
    Node *pTmp;
    
    if(NULL==pHead){
        printf("OrrderList函數執行，鏈表為空\n");
        return 0; 
    } 
    if(x<1){
        printf("OrrderList函數執行，x值非法\n");
        return 0; 
    } 
    while(pHead!=NULL){
        if((pHead->element)>x){
            break;
        }
        pHead=pHead->next;
    }
    if(pHead==NULL){
        printf("OrrderList函數執行，該函數中沒有該值\n");
        return 0; 
    } 
    
    pTmp=(Node *)malloc(sizeof(Node));
    if(pTmp==NULL) exit(1);
    memset(pTmp,0,sizeof(Node));
    pTmp->next=pHead->next;
    pHead->next=pTmp;
    pTmp->element=x;
    
    printf("OrrderList函數成功插入數值%d\n",x);
    return 1;
}
/*14，從單鏈表中刪除頭結點並返回其值，失敗則停止程序運行*/
int DelHeadList(Node **pList){
    
    Node *pHead;
    pHead=*pList;
    if(pHead!=NULL){
        printf("DelHeadList函數執行，函數首元素為%d刪除成功\n",pHead->element);
    }
    else{
        printf("DelHeadList函數執行，倆鳥為空");
        return 0;
    }
    *pList=pHead->next;
    return 1;
}
/*15,從鏈表中刪除表尾節點並返回其值，若失敗停止程序運行*/
int DelLastList(Node *pNode){
    
    Node *pHead;
    Node *pTmp;
    
    pHead=pNode;
    while(pHead->next!=NULL){
        
        pTmp=pHead;
        pHead=pHead->next;
    }
    printf("鏈表尾刪除原元素%d成功\n",pHead->element);
    free(pHead);
    pTmp->next=NULL; 
    return 1;
}
/*16,從鏈表中刪除第pos個結點並返回他的值，失敗則停止程序運行*/
int DelPos(Node *pNode,int pos){
    
    Node *pHead;
    pHead=pNode;
    Node *pTmp;
    int i=0;
    
    if(NULL==pHead){
        printf("DelPos函數執行，鏈表為空");
        return 0;
    }
    if(pos<1){
        printf("DlePos函數之心，pos值非法");
        return 0;
    }
    while(pHead!=NULL){
        ++i;
        if(i==pos){
            break;
        }
        pTmp=pHead;
        pHead=pHead->next;
    }
    if(i<pos){
        printf("DelPos函數執行，pos值超出鏈表長度");
        return 0; 
    }
    printf("DelPos函數執行成功，結點%d刪除數值%d\n",pos,pHead->element);
    return 1;
}
/*17,從單鏈表中刪除值為x的第一個結點，若刪除成功返回1， 否則返回0*/
int Dlex(Node **pNode,int x){
    
    Node *pHead;
    Node *pTmp;
    pHead=*pNode;
    int i=0;
    
  if(NULL==pHead){    
        printf("Delx函數執行，鏈表為空");
        return 0;    
    }
    if(x<0){
        printf("Delx函數執行，給定值x不合法\n");
        return 0;
    }
    while((pHead->element!=x)&&(NULL!=pHead->next)){
        
        i++;
        pTmp=pHead;
        pHead=pHead->next;
        
    }
    if(pHead->element!=x){
        printf("Delx函數執行，在鏈表中沒有找到x值\n");
        return 0;
    }
    if((i==0)&&(NULL!=pHead->next)){
        printf("Delx函數執行，在鏈表首部找到此袁術，此袁術已經被刪除");
        free(pHead);
        return 1; 
    }
    printf("Delx函數執行首個為%d元素被刪除\n");
    free(pHead);
    return 1;
} 
/*18,交換兩個元素的位置*/
int exchange2pos(Node *pNode,int pos1,int pos2){
    
    Node *pHead;
    int *pTmp;
    int *pInsert;
    int a;
    int i=0;
    
    if(pos1<1||pos2<1){
        printf("DelPos函數執行，pos值非法\n");
        return 0;
    }
    pHead=pNode;
    while(pHead!=NULL){
        ++i;
        if(i==pos1){
            break;
        }
        pHead=pHead->next;
        
    }
    if(i<pos1){
        printf("DelPos函數執行，pos1值超出鏈表長度\n");
                return 0;
    }
    pTmp=&(pHead->element);
    i=0;
    pHead=pNode;
    while(pHead!=NULL){
        ++i;
        if(i==pos2){
            break;
        } 
        pHead=pHead->next;
    }
        if(i<pos2){
        printf("DelPos函數執行，pos2值超出鏈表長度\n");
                    return 0;
    }
    pInsert=&(pHead->element);
    a=*pTmp;
    *pTmp=*pInsert;
    *pInsert=a;
    
    printf("DelPos函數執行，交換第%d個和第%d個點的值\n",pos1,pos2);
    return 1;
    }
    
int swap(int *p1,int *p2){
    int a;
    if(*p1>*p2){
        a=*p1;
        *p1=*p2;
        *p2=a;
    }
    return 0;
}

/*19，將鏈表進行冒泡排序*/
int Arrange(Node *pNode){
    
    Node *pHead;
    pHead=pNode;
    
    int a=0,i,j;
    if(NULL==pHead){
        printf("Arrange函數執行，鏈表為空\n");
        return 0;
    }
    while(pHead!=NULL){
        ++a;
        pHead=pHead->next;
    }
    
    pHead=pNode;
    for(i=0;i<a-1;i++){
        
        for(j=1;j<a-i;j++){
            swap(&(pHead->element),&(pHead->next->element));
            pHead=pHead->next;
        }
        pHead=pNode;
    }
    printf("Arrange函數執行，鏈表排序完畢！\n");
    return 0;
}




int main()
{
    Node *pList=NULL;
    int length=0;
    
    elemType posElem;
    
    initList(&pList);
    printList(pList);
    
    pList=creatList(pList);
    printList(pList);
    
    sizeList(pList);
    printList(pList);
    
    isEmptyList(pList);
    
    
    posElem=getElement(pList,3);
    printList(pList);
    
    getElemAddr(pList,5);
    
    modifyElem(pList,4,1);
    printList(pList);
    
    
    insertHeadList(&pList,5);
    printList(pList);
    
    insertLastList(pList,6);
    printList(pList);
    
    
    isAddPos(pList,4,5);
    printList(pList);
    
    
    OrrderList(pList,6);
    printList(pList);
    
    
    DelHeadList(&pList);
    printList(pList);
    
        
    DelLastList(pList);
    printList(pList);
    
    
    DelPos(pList,3);
    printList(pList);
    
    
    Dlex(&pList,5);
    printList(pList);
    
    
    exchange2pos(pList,2,5);
    printList(pList);
    
    Arrange(pList);
    printList(pList);
    
    clearList(pList);
    return 0;
    
}

 

總結：

進一步理解怎樣構造函數、調用、函數之間的關系。

memset函數與L=(linklist)malloc(sizeof(Node))作用？

malloc函數：

L=(linklist)malloc(sizeof(Node))作用是生成一個新結點做頭結點，頭指針L指向頭結點

memset函數：

void * memset (void * p,int c,size_t n);

其中，指針p為所操作的內存空間的首地址，c為每個字節所賦的值，n為所操作內存空間的字節長度，也就是內存被賦值為c的字節數。

在使用memset時經常要注意的它是以字節為單位進行賦值的，所賦值的范圍是0x00～0xFF。若想要對一個double或int型的數組賦值時，就特別需要注意這一點：

原文地址： http://www.cppblog.com/matrix/archive/2010/07/07/119531.html