数据结构与算法实战 1.链表 （青岛大学 周强）

//当只需要做查找操作的时候 最好的是用顺序表O(1) 
//经常需要做插入和删除的时候 用链表,当然如果这个位置在表末尾，用顺序表也行
//当经常删除和插入的位置在表头或者中间的时候，顺序表要挪很多次
//空间上：链表要比顺序表消耗大 因为多了指针域 
 /*C++中用stl list就能用链表了 头文件是<list> 
    JAVA中用链表就是引入LinkedList 和ArrayList的使用方法一样 
 */
 
/*
带头指针：第一个头结点就存放数据，但是有head pointer指向这个节点
带头结点：第一个头结点不存放数据，只是用来索引链表的起始位置 
相比较：
        head node
            |
        [    ] -> [    ] -> [    ] -> ....    
            
        带头结点的比带头指针的要多耗一个空间
        
        
        head pointer
            |
        ??????     -> [ ] -> [ ] -> [ ]
        带头指针在遍历过程中会（可以）发生变化
        而带头结点的不能改变指针域，只能改变头结点的指针域 
*/
#include<cstdio>
#include<iostream>
#include<cstdlib>

using namespace std;

struct Node{
    int data;
    struct Node* next;
};

typedef struct Node* LList;

void init(struct Node **phead){
    *phead = NULL;
}

int getLength(struct Node* head){
    int len = 0;
    while(head != NULL){
        len ++;
        head = head->next;//并没有改变头指针 只是修改了head这个局部变量 
    }
    
    return len;
}

void printList(struct Node* head){
    while(head!=NULL){
        printf("%d, ",head->data);
        head = head->next;//并没有改变头指针 只是修改了head这个局部变量 
    }
    printf("\n");
}

struct Node* createNode(int x){
    struct Node* t;
    //这里应该要加入一个判断剩余空间是否足够malloc 
    t = (struct Node*)malloc(sizeof(struct Node));
    t->next = NULL;
    t->data = x;
    return t;
}

//因为查找第k-1个点在insert和remove中都要用到
//我们在编程中应该尽量不要去复制代码 而是封装成函数
//尽管函数名叫findK,但是我们找的是第k-1个，所以函数传值传的是k-1 
struct Node * findKth(struct Node* head, int k){
    int count = 1;
    struct Node* p;
    p = head;
    while(p != NULL && count < k){
        p = p->next;
        count++;
    }
    //p可能为空 但是无所谓 下面调用这个函数的地方也有判断语句 
    return p;
} 


//** 指针的指针，存的是指针的地址 
bool insert(struct Node** phead, int k, int x){
    if(k < 1){
        return false;
    }
    //在第一个点插入，要把头指针指向这个点
    else if(k == 1){
        struct Node *t;
        //注意createNode后，t->next = NULL
        //假如这个链表原来不是个空表的话，原来的数据都会丢失
        t = createNode(x);
        //要把原先的点的next赋值给t才行 
        t->next = *phead;
        *phead = t;
        return true;
    }
    
    //在第一个点后面插入的情况 
    //一个个去遍历找到k-1的位置 如果k-1不存在那就没法插入了
    //例如1 2 3 4,插在6是插不了，插在5就可以
    struct Node * p;//存k-1的位置
    /*
    int count = 1;//用来计数
    p = *phead; 
    //当循环判断条件里面的范围不确定的时候，先试着运行一下等下再修改也行 
    while(p!=NULL && count < k - 1){
        p = p->next;
        count ++; 
    } 
    封装成了findKth 
    */
    //尽管函数名叫findK,但是我们找的是第k-1个，所以函数传值传的是k-1 
    p = findKth(*phead, k - 1);
    
    if(p){
        struct Node* t;
        //因为(struct Node*)malloc(sizeof(struct Node));要在很多地方用
        //干脆就搞成一个函数算了 
        t = createNode(x); 
        t->next = p->next;
        p->next = t;
        return true;
    }
    else{// 1 2 3 4你要插入6，p会指向前一个，就是空的，就插不进去 
        return false;
    }
}

bool removeNode(struct Node** phead, int k, int *px){
    //区分第一个节点和后面的节点
    if(k < 0){
        return false; 
    }    
    if(k == 1){
        if(*phead != NULL){
            *px = (*phead)->data;
            *phead = (*phead)->next;
            return true;
        }
        //*phead为空的时候这个表是个空表 
        else return false;
        
    }
    else{
        struct Node *p;
        p = findKth(*phead, k - 1);
        if(p == NULL || p->next == NULL){
            //要删除第k个，当没有第k-1位置，或者k-1往下是空（就没有第k个，也是错） 
            return false;
        }
        struct Node* t;
        t = p->next;
        p->next = t->next;
        *px = t->data;
        free(t);
        return true;
    }
}

int main(){
    LList head;//头指针
    //初始化 创建空链表
    init(&head);    
    //遍历（打印 求表长）
    int k =    getLength(head); 
    //printf("%d\n",k); 测试 
    printList(head);
    //int falg = insert(&head, 1, 11); 测试插入 
    insert(&head, 1, 11);//head表示哪个表，因为头指针可能会变，所以传head的地址；位置；元素数据 
    insert(&head, 1, 22);
    insert(&head, 2, 33);
    insert(&head, 4, 44);
    insert(&head, 6, 55);
    printList(head);
    int x;//传入x的地址，用x来获取删除的点的数值 
    removeNode(&head, 1, &x);//删除第一个点的时候会改变头指针，所以传入地址  
    //printf("%d\n",x);
    printList(head);
    return 0;
}