[c++] 鏈表各種操做詳解

鏈表概述

鏈表是一種常見的重要的數據結構。它是動態地進行存儲分配的一種結構。它能夠根據須要開闢內存單元。鏈表有一個「頭指針」變量,以head表示,它存放一個地址。該地址指向一個元素。鏈表中每個元素稱爲「結點」,每一個結點都應包括兩個部分:一爲用戶須要用的實際數據,二爲下一個結點的地址。所以,head指向第一個元素:第一個元素又指向第二個元素;……,直到最後一個元素,該元素再也不指向其它元素,它稱爲「表尾」,它的地址部分放一個「NULL」(表示「空地址」),鏈表到此結束。鏈表的各種操做包括:學習單向鏈表的建立、刪除、插入(無序、有序)、輸出、排序(選擇、插入、冒泡)、反序等等。node

 

建立n個節點的鏈表數據結構

#include "stdlib.h"  
#include "stdio.h"  
  
#define NULL 0  
#define LEN sizeof(struct student)  
  
struct student  
{  
    int num;              //學號   
    float score;          //分數,其餘信息能夠繼續在下面增長字段  
    struct student *next;       //指向下一節點的指針  
};  
  
int n;  //節點總數   
/* 
========================== 
功能:建立n個節點的鏈表 
返回:指向鏈表表頭的指針 
========================== 
*/  
struct student *Create()  
{  
    struct student *head;       //頭節點  
    struct student *p1 = NULL;  //p1保存建立的新節點的地址  
    struct student *p2 = NULL;  //p2保存原鏈表最後一個節點的地址  
  
    n = 0;          //建立前鏈表的節點總數爲0:空鏈表  
    p1 = (struct student *) malloc (LEN);   //開闢一個新節點  
    p2 = p1;            //若是節點開闢成功,則p2先把它的指針保存下來以備後用  
  
    if(p1==NULL)        //節點開闢不成功  
    {  
        printf ("\nCann't create it, try it again in a moment!\n");  
        return NULL;  
    }  
    else                //節點開闢成功  
    {  
        head = NULL;        //開始head指向NULL  
        printf ("Please input %d node -- num,score: ", n + 1);  
        scanf ("%d %f", &(p1->num), &(p1->score));    //錄入數據  
    }  
    while(p1->num != 0)      //只要學號不爲0,就繼續錄入下一個節點  
    {  
        n += 1;         //節點總數增長1個  
        if(n == 1)      //若是節點總數是1,則head指向剛建立的節點p1  
        {  
            head = p1;  
            p2->next = NULL;  //此時的p2就是p1,也就是p1->next指向NULL。  
        }  
        else  
        {  
            p2->next = p1;   //指向上次下面剛剛開闢的新節點  
        }  
  
        p2 = p1;            //把p1的地址給p2保留,而後p1產生新的節點  
  
        p1 = (struct student *) malloc (LEN);  
        printf ("Please input %d node -- num,score: ", n + 1);  
        scanf ("%d %f", &(p1->num), &(p1->score));  
    }  
    p2->next = NULL;     //此句就是根據單向鏈表的最後一個節點要指向NULL  
  
    free(p1);           //p1->num爲0的時候跳出了while循環,而且釋放p1  
    p1 = NULL;          //特別不要忘記把釋放的變量清空置爲NULL,不然就變成"野指針",即地址不肯定的指針  
    return head;        //返回建立鏈表的頭指針   
}  

 

輸出鏈表中節點學習

/* 
=========================== 
 功能:輸出節點 
 返回: void 
=========================== 
*/  
void Print(struct student *head)  
{  
    struct student *p;  
    printf ("\nNow , These %d records are:\n", n);  
    p = head;  
    if(head != NULL)        //只要不是空鏈表,就輸出鏈表中全部節點  
    {  
        printf("head is %o\n", head);    //輸出頭指針指向的地址  
        do  
        {  
            /* 
            輸出相應的值:當前節點地址、各字段值、當前節點的下一節點地址。 
            這樣輸出便於讀者形象看到一個單向鏈表在計算機中的存儲結構,和咱們 
            設計的圖示是如出一轍的。 
            */  
            printf ("%o   %d   %5.1f   %o\n", p, p->num, p->score, p->next);  
            p = p->next;     //移到下一個節點  
        }  
        while (p != NULL);  
    }  
}  

 

刪除指定學號的節點.net

/* 
========================== 
 功能:刪除指定節點 
  (此例中是刪除指定學號的節點) 
 返回:指向鏈表表頭的指針 
========================== 
*/  
struct student *Del (struct student *head, int num)  
{  
    struct student *p1;     //p1保存當前須要檢查的節點的地址  
    struct student *p2;     //p2保存當前檢查過的節點的地址  
    if (head == NULL)       //是空鏈表(結合圖3理解)  
    {  
        printf ("\nList is null!\n");  
        return head;  
    }  
  
    //定位要刪除的節點  
    p1 = head;  
    while (p1->num != num && p1->next != NULL)    //p1指向的節點不是所要查找的,而且它不是最後一個節點,就繼續往下找  
    {  
        p2 = p1;            //保存當前節點的地址  
        p1 = p1->next;       //後移一個節點  
    }  
  
    if(p1->num==num)     //找到了。(結合圖四、5理解)  
    {  
        if (p1 == head)     //若是要刪除的節點是第一個節點  
        {  
            head = p1->next; //頭指針指向第一個節點的後一個節點,也就是第二個節點。這樣第一個節點就不在鏈表中,即刪除  
        }  
        else            //若是是其它節點,則讓原來指向當前節點的指針,指向它的下一個節點,完成刪除  
        {  
            p2->next = p1->next;  
        }  
  
        free (p1);      //釋放當前節點  
        p1 = NULL;  
        printf ("\ndelete %ld success!\n", num);  
        n -= 1;         //節點總數減1個  
    }  
    else                //沒有找到  
    {  
        printf ("\n%ld not been found!\n", num);  
    }  
  
    return head;  
}  

 

插入指定節點的後面設計

/* 
========================== 
 功能:插入指定節點的後面 
  (此例中是指定學號的節點) 
 返回:指向鏈表表頭的指針 
========================== 
*/  
struct student *Insert (struct student *head, int num, struct student *node)  
{  
    struct student *p1;     //p1保存當前須要檢查的節點的地址  
    if (head == NULL)       //(結合圖示7理解)  
    {  
        head = node;  
        node->next = NULL;  
        n += 1;  
        return head;  
    }  
  
    p1 = head;  
    while(p1->num != num && p1->next != NULL)  //p1指向的節點不是所要查找的,而且它不是最後一個節點,繼續往下找  
    {  
        p1 = p1->next;       //後移一個節點  
    }  
  
    if (p1->num==num)        //找到了(結合圖示8理解)  
    {  
        node->next = p1->next;    //顯然node的下一節點是原p1的next  
        p1->next = node;     //插入後,原p1的下一節點就是要插入的node  
        n += 1;         //節點總數增長1個  
    }  
    else  
    {  
        printf ("\n%ld not been found!\n", num);  
    }  
    return head;  
}  

 

反序鏈表指針

/* 
========================== 
 功能:反序節點 
  (鏈表的頭變成鏈表的尾,鏈表的尾變成頭) 
 返回:指向鏈表表頭的指針 
========================== 
*/  
  
struct student *Reverse (struct student *head)  
{  
    struct student *p;      //臨時存儲  
    struct student *p1;     //存儲返回結果  
    struct student *p2;     //源結果節點一個一個取  
  
    p1 = NULL;          //開始顛倒時,已顛倒的部分爲空  
    p2 = head;          //p2指向鏈表的頭節點  
    while(p2 != NULL)  
    {  
        p = p2->next;  
        p2->next = p1;  
        p1 = p2;  
        p2 = p;  
    }  
    head = p1;  
    return head;  
}  

 

對鏈表進行選擇排序blog

/* 
========================== 
 功能:選擇排序(由小到大) 
 返回:指向鏈表表頭的指針 
========================== 
*/  
struct student *SelectSort (struct student *head)  
{  
    struct student *first;     //排列後有序鏈的表頭指針  
    struct student *tail;      //排列後有序鏈的表尾指針  
    struct student *p_min;     //保留鍵值更小的節點的前驅節點的指針  
    struct student *min;       //存儲最小節點  
    struct student *p;         //當前比較的節點  
  
    first = NULL;  
    while(head != NULL)       //在鏈表中找鍵值最小的節點  
    {  
        //注意:這裏for語句就是體現選擇排序思想的地方  
        for (p = head, min = head; p->next != NULL; p = p->next)  //循環遍歷鏈表中的節點,找出此時最小的節點  
        {  
            if (p->next->num < min->num)     //找到一個比當前min小的節點  
            {  
                p_min = p;        //保存找到節點的前驅節點:顯然p->next的前驅節點是p  
                min = p->next;     //保存鍵值更小的節點  
            }  
        }  
  
        //上面for語句結束後,就要作兩件事;一是把它放入有序鏈表中;二是根據相應的條件判斷,安排它離開原來的鏈表  
  
        //第一件事  
        if (first == NULL)     //若是有序鏈表目前仍是一個空鏈表  
        {  
            first = min;        //第一次找到鍵值最小的節點  
            tail = min;        //注意:尾指針讓它指向最後的一個節點  
        }  
        else              //有序鏈表中已經有節點  
        {  
            tail->next = min;    //把剛找到的最小節點放到最後,即讓尾指針的next指向它  
            tail = min;           //尾指針也要指向它  
        }  
  
        //第二件事  
        if (min == head)            //若是找到的最小節點就是第一個節點  
        {  
            head = head->next;      //顯然讓head指向原head->next,即第二個節點,就OK  
        }  
        else            //若是不是第一個節點  
        {  
            p_min->next = min->next;  //前次最小節點的next指向當前min的next,這樣就讓min離開了原鏈表  
        }  
    }  
  
    if (first != NULL)      //循環結束獲得有序鏈表first  
    {  
        tail->next = NULL;   //單向鏈表的最後一個節點的next應該指向NULL  
    }  
    head = first;  
    return head;  
}  

 

對鏈表進行冒泡排序排序

/* 
========================== 
 功能:冒泡排序(由小到大) 
 返回:指向鏈表表頭的指針 
========================== 
*/  
struct student *BubbleSort (struct student *head)  
{  
    struct student *endpt;    //控制循環比較  
    struct student *p;        //臨時指針變量  
    struct student *p1,*p2;  
  
    p1 = (struct student *) malloc (LEN);  
    p1->next = head;        //注意理解:咱們增長一個節點,放在第一個節點的前面,主要是爲了便於比較。由於第一個節點沒有前驅,咱們不能交換地址  
    head = p1;                 //讓head指向p1節點,排序完成後,咱們再把p1節點釋放掉  
  
    for (endpt = NULL; endpt != head; endpt = p)    //結合第6點理解  
    {  
        for (p = p1 = head; p1->next->next != endpt; p1 = p1->next)  
        {  
            if (p1->next->num > p1->next->next->num)  //若是前面的節點鍵值比後面節點的鍵值大,則交換  
            {  
                p2 = p1->next->next;    //結合第1點理解  
                p1->next->next = p2->next;   //結合第2點理解  
                p2->next = p1->next;   //結合第3點理解  
                p1->next = p2;     //結合第4點理解  
                p = p1->next->next;   //結合第6點理解  
            }  
        }  
    }  
  
    p1 = head;              //把p1的信息去掉  
    head = head->next;       //讓head指向排序後的第一個節點  
    free (p1);          //釋放p1  
    p1 = NULL;          //p1置爲NULL,保證不產生「野指針」,即地址不肯定的指針變量  
  
    return head;  
}  

reference:內存

http://blog.csdn.net/hackbuteer1/article/details/6591486/get

相關文章
相關標籤/搜索