③.链表

一：定义

链表是一系列不存在内存中相连的结构组成。每一个结构均含有表元素和指向包含该元素后继元素的结构的指针：Next指针。最后一个单元的Next指向NULL

为了方便，我们使用表头(header)或哑节点（dummy node）来指向第一个节点

 

二：操作

具体链表例程见代码

 

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

typedef struct Node *Position;
typedef struct Node *List;

struct Node{      //链表节点定义
    int Element;
    Position Next;
};

void CreateList(List L){
    int a;
    Position pre,cur;
    pre = cur = L;
    scanf_s("%d", &a);
    while (a != -1){
        cur = (Position)malloc(sizeof(struct Node));
        cur->Element = a;
        pre->Next = cur;
        pre = cur;
        scanf_s("%d", &a);
    }
    cur->Next = NULL;   //不忘
}

void PrintList(List L){
    Position P;
    P = L->Next;
    while (P != NULL){
        printf("%d ", P->Element);
        P = P->Next;
    }
}
int isEmpty(List L){
    return L->Next==NULL;
}

int isLast(Position P, List L){
    return P->Next == NULL;
}

Position Find(int X, List L){
    L = L->Next;
    while (L != NULL&&L->Element != X){
        L = L->Next;
    }
    return L;
}

Position FindPrevious(int X, List L){
    while (L->Next != NULL&&L->Next->Element != X){
        L = L->Next;
    }
    return L;
}

void Delete(int X, List L){
    Position Temp;
    Position P = FindPrevious(X, L);
    if (!isLast(P, L)){
        Temp = P->Next;
        P ->Next = P->Next->Next;
        free(Temp);
    }
}

void Insert(int X, Position P){
    Position Temp = (Position)malloc(sizeof(struct Node));
    Temp->Next = P->Next;
    P->Next = Temp;
    Temp->Element = X;
}

void DeleteList(List L){
    Position Temp, P;
    P = L->Next;
    while (P != NULL){
        Temp = P->Next;
        free(P);
        P = Temp;

    }
    L->Next = NULL;  //不忘



}

 

唯一要注意的就是链表末节点->Next=NULL这句不要忘记

 

 

 三：应用

①计数排序：

　  如果我们有Ｎ个整数，范围从１到Ｍ，则我们可以有Ｍ个空位置，也就是留置一个数组，称为Count,大小为M，初始化为0.当Ai读入时，Count[Ai]加1，等全部输入读进后，扫描一遍数组就可以打印输出排好序的表。 时间复杂度：O(M+N)

    A是原始数据， C是每个数据重复了几次，相当于Count数组，C’是Count[i]+Count[i-1], 然后逆序把数字一个个重新填放入B数组，就是排好序的啦，具体代码实现见基数排序方法二。

②基数排序：

    举例来说明：假设我们有10个数，范围在0-999之间，这样我们就不能用计数排序，因为M太大了。所以我们就想用多趟计数排序。并且，此时是用最低位优先的方式进行计数排序。

    eg:我们现在有0,1,512,343,64,125,216,27,8,729 十个数：

第一次：（按个位排序）

           然后再按照顺序收起来：0,1,512,343,64,125,216,27,8,729

第二次：（按十位排序）

           然后再按照顺序收起来：0,1,8,512,216,125,27,729,343,64

第三次：（按百位排序）

这次收起来就排好序了：0,1,8,27,64,125,216,343,512,729

 

时间复杂度：O(P(N+B)) P是排序趟数，N是排序元素的个数，B是Count

 

代码一：

这个使用一个二维数组当做一个个桶，每个桶的第一个数据代表桶内有几个数字，初始置为0。

int GetDigit(int x, int d){  //取得x的第d位数,个位为第1位数依次递增
    int a[10] = { 0,1, 10, 100, 1000 };
    
    return (x / a[d])% 10;
}


void Radix_Sort(int *a, int length){
    int Bucket[10][100]; //假设一个桶最多能装100个数据
    int i, num,j, k = 0;
    for (num = 1; num < 4; num++){
        k = 0;
        for (i = 0; i < 10; i++){
            Bucket[i][0] = 0; //这位记录第i个桶有多少个数据
        }
        for (i = 0; i < length; i++){
            Bucket[GetDigit(a[i], num)][++Bucket[GetDigit(a[i], num)][0]] = a[i]; //把数据放到相应的桶中
        }
        
        for (i = 0; i < 10; i++){  //从桶中回收数据
            for (j = 1;j <= Bucket[i][0]; j++){
                a[k++] = Bucket[i][j];
            }
        }
    }
}

 

代码二：

这个就完全用到的是计数排序的实现方法，用了一个Count数组。 就是计数排序重复来个几次。

int GetDigit(int x, int d){  //取得x的第d位数,个位为第1位数依次递增
    int a[10] = { 0,1, 10, 100, 1000 };
    
    return (x / a[d])% 10;
}


void Radix_Sort(int *a, int length){
    int Count[10]; //Count数组是每个桶里有多少个数字
    int Bucket[10];
    int i, j; 
    for (j = 1; j < 4; j++){
        for (i = 0; i < 10; i++){  //初始置零
            Count[i] = 0;
        }
        for (i = 0; i < length; i++){
            Count[GetDigit(a[i], j)]++;
        } 
        for (i = 1; i < 10; i++){  //这一步就很像计数排序的方法了
            Count[i] += Count[i - 1];
        }
        for (i = length - 1; i >= 0; i--){   
            Bucket[--Count[GetDigit(a[i], j)]] = a[i];
        }
        for (i = 0; i < 10; i++){
            a[i] = Bucket[i];
        }
    }
}

 

四.链表的游标实现

如果有些语言没有指针，那链表不就没有next指针指来指去了吗！所以这里我们就有游标(cursor)实现法：

     我们用数组下标代表地址，所以需要有一个全局的结构体数组。

  比如这张图：

对于Next，0代表的指针是null.然后这张表显示了两个链表，分别是3-7-8-2：cdf 以及：5-10-1-9：abe

然后0-6-4-0代表的是没分配出去的地址:therefore

引出在游标实现中的Malloc和free:

malloc:要新给出一个地址，所以将表头后面的第一个元素删除，按照上表就是0-4-0，如果没有空间可以用了，那返回就是0

free:回收一个，放到最前面:(比如回收8)就是0-8-6-4-0

 

 

 

 

一些习题：

3.5：

L和P已经排序，求L∪P

void  Union(List L, List P){
    List Final = (List)malloc(sizeof(struct Node));//最终并集的结果
    Final->Next = NULL;
    L = L->Next; P = P->Next;
    while (L != NULL&&P != NULL){
        if (L->Element > P->Element){
            Insert(L->Element, Final);
            L = L->Next;
        }
        else if (L->Element < P->Element){
            Insert(P->Element, Final);
            P = P->Next;
        }
        else{
            Insert(P->Element, Final);
            L = L->Next; P = P->Next;
        }

    }
    while (L != NULL){
        Insert(L->Element, Final);
        L = L->Next;
    }
    while (P != NULL){
        Insert(P->Element, Final);
        P = P->Next;
    }
}

 

3.12：

反转单链表 用O(N)的时间。

如果用栈的话就要用O(N)的空间，不用栈的话只要常数附加空间

法1：
    List pre, temp, temp1;
    List cur = (List)malloc(sizeof(struct Node));
    CreateList(cur);
    PrintList(cur); printf("\n");
    pre = NULL; temp1 = cur; cur = cur->Next;
    while (cur != NULL){
        temp = cur->Next;
        cur->Next = pre;
        pre = cur;
        cur = temp;
    }
    temp1->Next = pre;
    




法2：
    //用栈 卧槽
    int top = -1; List temp1, temp;
    List cur = (List)malloc(sizeof(struct Node));
    temp = temp1 = cur;
    CreateList(cur);
    PrintList(cur); printf("\n");
    Position stack[200];
    cur = cur->Next;
    while (cur != NULL){
        stack[++top] = cur;
        cur = cur->Next;
    }
    while (top != -1){
        temp->Next = stack[top--];
        temp = temp->Next;

    }
    temp->Next = NULL;