單鏈表反轉

時間  2019-12-12
標籤 鏈表 反轉 简体版
原文   原文鏈接

一. 先畫一個單鏈表，這個單鏈表有4個元素。思路就是，每次把第二個元素提到最前面來。好比下面是第一次交換，咱們先讓頭結點的next域指向結點a2，再讓結點a1的next域指向結點a3，最後將結點a2的next域指向結點a1，就完成了第一次交換。ios

第一次交換算法

而後進行相同的交換將結點a3移動到結點a2的前面，而後再將結點a4移動到結點a3的前面就完成了反轉。ide

 第二次交換函數

 第三次交換spa

思路1：.net

這裏咱們須要額外的兩個工做指針來輔助交換。這個下面的步驟慢慢理解下，結合圖片。注意結點之間的關係要先斷再連。設計

步驟：3d

  1. 定義當前結點 current，初始值爲首元結點，current = L->next;
  2. 定義當前結點的後繼結點 pnext， pnext = current->next; 
  3. 只要 pnext 存在，就執行如下循環：
    • 定義新節點 prev，它是 pnext的後繼結點，prev = pnext->next;
    • 把pnext的後繼指向current, pnext->next = current;
    • 此時，pnext 實際上已經到了 current 前一位成爲新的current，因此這個時候 current 結點實際上成爲新的 pnext，current = pnext;
    • 此時，新的 current 就是 pnext，current = pnext;
    • 而新的 pnext 就是 prev，pnext = prev;
  4. 最後將頭結點與 current 從新連上便可，L->next = current;

函數設計以下：指針

/* 單鏈表反轉/逆序 */
LinkList ListReverse(LinkList L)
{
    LinkList current,pnext,prev;
    if(L == NULL || L->next == NULL)
        return L;
    current = L->next;  /* p1指向鏈表頭節點的下一個節點 */
    pnext = current->next;
    current->next = NULL;
    while(pnext)
    {
        prev = pnext->next;
        pnext->next = current;
        current = pnext;
        pnext = prev;
    }
    //printf("current = %d,next = %d \n",current->data,current->next->data);
    L->next = current;  /* 將鏈表頭節點指向p1 */
    return L;
}
View Code

思路2：code

不一樣于思路一的current一直是表的第一個結點，這裏的current始終是首元結點的值，函數須要每次對pnext從新賦值。先將current指向prev，再將pnext指向current，最後將頭結點指向pnext。

步驟以下：

  1. p = current->next; p 就至關於前面的 pnext。（圖1中a2即爲p）
  2. current->next = p->next; p->next 就至關於 prev的角色，這句代碼意思是 current 的後繼指向 prev.（至關於圖1中a1->next = a3(a2->next)）
  3. p->next = L->next; 這句就是 p 的後繼直接指向首元節點。（至關於圖1中a2->next = a1）
  4. L->next = p; 而後再將頭結點指向 p。（至關於圖1中L->next = a2）

代碼以下：

LinkList ListReverse2(LinkList L)
{
    LinkList current, p;

    if (L == NULL)
    {
        return NULL;
    }
    current = L->next;
    while (current->next != NULL)
    {
        p = current->next;
        current->next = p->next;
        p->next = L->next;
        L->next = p;
        ListTraverse(L);
        printf("current = %d, \n", current -> data);
    }
    return L;
}
View Code

如下代碼是模仿思路2本身實現的：

LinkList ListReverse4(LinkList L){ //4爲模仿2的思想本身實現的算法
    LinkList current,p;
    if(!L || !L->next){
        return L;
    }
    current = L->next;
    p = current->next;
    while(p){
        current->next = p->next;
        p->next = L->next;
        L->next = p;
        p = current->next;
    }
    return L;
}
View Code

2、最後附上完整代碼，反轉有兩個函數。

  • 方法1，current始終保持在第一位，pnext與prev遍歷並完成交換。
  • 方法2，current始終是原鏈表的第一個數，而後把pnext不斷移動到首位。
// 單鏈錶轉置.cpp : 定義控制檯應用程序的入口點。
//

#include "stdafx.h"
#include<iostream>
#include<time.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 20 /* 存儲空間初始分配量 */

using namespace std;

typedef int Status;/* Status是函數的類型,其值是函數結果狀態代碼，如OK等 */
typedef int ElemType;/* ElemType類型根據實際狀況而定，這裏假設爲int */

typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node;
/* 定義LinkList */
typedef struct Node *LinkList;

/* 初始化順序線性表 */
Status InitList(LinkList *L) //涉及到建立鏈表的必須用二級指針
{
    (*L)=(LinkList)malloc(sizeof(Node)); /* 產生頭結點,並使L指向此頭結點 */
    if(!(*L)) /* 存儲分配失敗 */
    {
        return ERROR;
    }
    (*L)->next=NULL; /* 指針域爲空 */

    return OK;
}

/* 初始條件：順序線性表L已存在。操做結果：返回L中數據元素個數 */
int ListLength(LinkList L)
{
    int i=0;
    LinkList p = L->next; /* p指向第一個結點 */
    while(p)
    {
        i++;
        p=p->next;
    }
    return i;
}

/* 初始條件：順序線性表L已存在。操做結果：將L重置爲空表 */
Status ClearList(LinkList L)
{
    LinkList p,q;
    p = L->next;           /*  p指向第一個結點 */
    while(p)                /*  沒到表尾 */
    {
        q=p->next;
        free(p);
        p=q;
    }
    L->next = NULL;        /* 頭結點指針域爲空 */
    return OK;
}

Status visit(ElemType c)
{
    printf("-> %d ",c);
    return OK;
}

/* 初始條件：順序線性表L已存在 */
/* 操做結果：依次對L的每一個數據元素輸出 */
Status ListTraverse(LinkList L)
{
    LinkList p=L->next;
    while(p)
    {
        visit(p->data);
        p=p->next;
    }
    printf("\n");
    return OK;
}

/* 初始條件：順序線性表L已存在，1≤i≤ListLength(L) */
/* 操做結果：用e返回L中第i個數據元素的值 */
Status GetElem(LinkList L,int i,ElemType *e)
{
    int j;
    LinkList p;        /* 聲明一結點p */
    p = L->next;        /* 讓p指向鏈表L的第一個結點 */
    j = 1;        /*  j爲計數器 */
    while (p && j < i)  /* p不爲空或者計數器j尚未等於i時，循環繼續 */
    {
        p = p->next;  /* 讓p指向下一個結點 */
        ++j;
    }
    if ( !p || j>i )
        return ERROR;  /*  第i個元素不存在 */
    *e = p->data;   /*  取第i個元素的數據 */
    return OK;
}

/* 初始條件：順序線性表L已存在 */
/* 操做結果：返回L中第1個與e知足關係的數據元素的位序。 */
/* 若這樣的數據元素不存在，則返回值爲0 */
int LocateElem(LinkList L,ElemType e)
{
    int i=0;
    LinkList p=L->next;
    while(p)
    {
        i++;
        if(p->data==e) /* 找到這樣的數據元素 */
                return i;
        p=p->next;
    }

    return 0;
}

/*  隨機產生n個元素的值，創建帶表頭結點的單鏈線性表L（頭插法） */
void CreateListHead(LinkList *L, int n)  //涉及到建立鏈表的必須用二級指針
{
    LinkList p;
    int i;
    srand(time(0));                         /* 初始化隨機數種子 */
    (*L) = (LinkList)malloc(sizeof(Node));
    (*L)->next = NULL;                      /*  先創建一個帶頭結點的單鏈表 */
    for (i=0; i < n; i++)
    {
        p = (LinkList)malloc(sizeof(Node)); /*  生成新結點 */
        p->data = rand()%100+1;             /*  隨機生成100之內的數字 */
        p->next = (*L)->next;
        (*L)->next = p;                        /*  插入到表頭 */
    }
}

/*  隨機產生n個元素的值，創建帶表頭結點的單鏈線性表L（尾插法） */
void CreateListTail(LinkList *L, int n) //涉及到建立鏈表的必須用二級指針
{
    LinkList p,r;
    int i;
    srand(time(0));                      /* 初始化隨機數種子 */
    (*L) = (LinkList)malloc(sizeof(Node)); /* L爲整個線性表 */
    r = *L;                                /* r爲指向尾部的結點 */
    for (i=0; i < n; i++)
    {
        p = (Node *)malloc(sizeof(Node)); /*  生成新結點 */
        p->data = rand()%100+1;           /*  隨機生成100之內的數字 */
        r->next=p;                        /* 將表尾終端結點的指針指向新結點 */
        r = p;                            /* 將當前的新結點定義爲表尾終端結點 */
    }
    r->next = NULL;                       /* 表示當前鏈表結束 */
}

/* 初始條件：順序線性表L已存在,1≤i≤ListLength(L)， */
/* 操做結果：在L中第i個位置以前插入新的數據元素e，L的長度加1 */
Status ListInsert(LinkList L,int i,ElemType e)  //此時能夠不用二級指針
{
    int j;
    LinkList p,s;
    p = L;     /* 聲明一個結點 p，指向頭結點 */
    j = 1;
    while (p && j < i)     /* 尋找第i個結點 */
    {
        p = p->next;
        ++j;
    }
    if (!p || j > i)
        return ERROR;   /* 第i個元素不存在 */
    s = (LinkList)malloc(sizeof(Node));  /*  生成新結點(C語言標準函數) */
    s->data = e;
    s->next = p->next;      /* 將p的後繼結點賦值給s的後繼  */
    p->next = s;          /* 將s賦值給p的後繼 */
    return OK;
}

/* 初始條件：順序線性表L已存在，1≤i≤ListLength(L) */
/* 操做結果：刪除L的第i個數據元素，並用e返回其值，L的長度減1 */
Status ListDelete(LinkList L,int i,ElemType *e)  //此時能夠不用二級指針
{
    int j;
    LinkList p,q;
    p = L;
    j = 1;
    while (p->next && j < i)    /* 遍歷尋找第i個元素 */
    {
        p = p->next;
        ++j;
    }
    if (!(p->next) || j > i)
        return ERROR;           /* 第i個元素不存在 */
    q = p->next;
    p->next = q->next;            /* 將q的後繼賦值給p的後繼 */
    *e = q->data;               /* 將q結點中的數據給e */
    free(q);                    /* 讓系統回收此結點，釋放內存 */
    return OK;
}

/* 單鏈表反轉/逆序 */
LinkList ListReverse(LinkList L)
{
    LinkList current,pnext,prev;
    if(L == NULL || L->next == NULL)
        return L;
    current = L->next;  /* p1指向鏈表頭節點的下一個節點 */
    pnext = current->next;
    current->next = NULL;
    while(pnext)
    {
        prev = pnext->next;
        pnext->next = current;
        current = pnext;
        pnext = prev;
    }
    //printf("current = %d,next = %d \n",current->data,current->next->data);
    L->next = current;  /* 將鏈表頭節點指向p1 */
    return L;
}

LinkList ListReverse2(LinkList L)
{
    LinkList current, p;

    if (L == NULL)
    {
        return NULL;
    }
    current = L->next;
    while (current->next != NULL)
    {
        p = current->next;
        current->next = p->next;
        p->next = L->next;
        L->next = p;
        ListTraverse(L);
        printf("current = %d, \n", current -> data);
    }
    return L;
}

LinkList ListReverse4(LinkList L){ //4爲模仿2的思想本身實現的算法
    LinkList current,p;
    if(!L || !L->next){
        return L;
    }
    current = L->next;
    p = current->next;
    while(p){
        current->next = p->next;
        p->next = L->next;
        L->next = p;
        p = current->next;
    }
    return L;
}
int main(int argc, char * argv[])
{
    LinkList L = NULL;
    Status i;
    int j,k,pos,value;
    char opp = NULL;
    ElemType e;

    i=InitList(&L);
    printf("鏈表L初始化完畢，ListLength(L)=%d\n",ListLength(L));

    printf("\n1.整表建立（頭插法） \n2.整表建立（尾插法） \n3.遍歷操做 \n4.插入操做");
    printf("\n5.刪除操做 \n6.獲取結點數據 \n7.查找某個數是否在鏈表中 \n8.置空鏈表");
    printf("\n9.鏈表反轉逆序");
    printf("\n0.退出 \n請選擇你的操做：\n");
    while(opp != '0'){
        scanf("%c",&opp);
        switch(opp){
            case '1':
                CreateListHead(&L,10);
                printf("總體建立L的元素(頭插法)：\n");
                ListTraverse(L);
                printf("\n");
                break;

            case '2':
                CreateListTail(&L,10);
                printf("總體建立L的元素(尾插法)：\n");
                ListTraverse(L);
                printf("\n");
                break;

            case '3':
                ListTraverse(L);
                printf("\n");
                break;

            case '4':
                printf("要在第幾個位置插入元素？");
                scanf("%d",&pos);
                printf("插入的元素值是多少？");
                scanf("%d",&value);
                ListInsert(L,pos,value);
                ListTraverse(L);
                printf("\n");
                break;

            case '5':
                printf("要刪除第幾個元素？");
                scanf("%d",&pos);
                ListDelete(L,pos,&e);
                printf("刪除第%d個元素成功，如今鏈表爲：\n", pos);
                ListTraverse(L);
                printf("\n");
                break;

            case '6':
                printf("你須要獲取第幾個元素？");
                scanf("%d",&pos);
                GetElem(L,pos,&e);
                printf("第%d個元素的值爲：%d\n", pos, e);
                printf("\n");
                break;

            case '7':
                printf("輸入你須要查找的數：");
                scanf("%d",&pos);
                k=LocateElem(L,pos);
                if(k)
                    printf("第%d個元素的值爲%d\n",k,pos);
                else
                    printf("沒有值爲%d的元素\n",pos);
                printf("\n");
                break;

            case '8':
                i=ClearList(L);
                printf("\n清空L後：ListLength(L)=%d\n",ListLength(L));
                ListTraverse(L);
                printf("\n");
                break;

            case '9':
                ListReverse4(L);
                printf("\n反轉L後\n");
                ListTraverse(L);
                printf("\n");
                break;

            case '0':
                exit(0);
        }
    }
    system("pause");
    return 0;
}
View Code

 本文參考：http://www.nowamagic.net/librarys/veda/detail/2241

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程