#include <stdio.h>
#include "string.h"
#include "ctype.h"
#include "stdlib.h"
#include "math.h"
#include "time.h"

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

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

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

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

typedef struct Node * LinkList;



//2.1 初始化單鏈表線性表
Status InitList(LinkList *L){
    
    //產生頭結點,并使用L指向此頭結點
    *L = (LinkList)malloc(sizeof(Node));
    //存儲空間分配失敗
    if(*L == NULL) return ERROR;
    //將頭結點的指針域置空
    (*L)->next = NULL;

    
    return OK;
}


//2.2 單鏈表插入
/*
 初始條件:順序線性表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;
    j = 1;
    
    //尋找第i-1個結點
    while (p && j<i) {
        p = p->next;
        ++j;
    }
    
    //第i個元素不存在
    if(!p || j>i) return ERROR;
    
    //生成新結點s
    s = (LinkList)malloc(sizeof(Node));
    //將e賦值給s的數值域
    s->data = e;
    //將p的后繼結點賦值給s的后繼
    s->next = p->next;
    //將s賦值給p的后繼
    p->next = s;
    
    return OK;
}


//2.3 單鏈表取值
/*
 初始條件: 順序線性表L已存在,1≤i≤ListLength(L);
 操作結果：用e返回L中第i個數據元素的值
 */
Status GetElem(LinkList L,int i,ElemType *e){
    
    //j: 計數.
    int j;
    //聲明結點p;
    LinkList p;
    
    //將結點p 指向鏈表L的第一個結點;
    p = L->next;
    //j計算=1;
    j = 1;
    
    
    //p不為空,且計算j不等于i,則循環繼續
    while (p && j<i) {
        
        //p指向下一個結點
        p = p->next;
        ++j;
    }
    
    //如果p為空或者j>i,則返回error
    if(!p || j > i) return ERROR;
    
    //e = p所指的結點的data
    *e = p->data;
    return OK;
    
    
}

//2.4 單鏈表刪除元素
/*
 初始條件：順序線性表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)->next;
    j = 1;
    
    //查找第i-1個結點,p指向該結點
    while (p->next && j<(i-1)) {
        p = p->next;
        ++j;
    }
    
    //當i>n 或者 i<1 時,刪除位置不合理
    if (!(p->next) || (j>i-1)) return  ERROR;
    
    //q指向要刪除的結點
    q = p->next;
    //將q的后繼賦值給p的后繼
    p->next = q->next;
    //將q結點中的數據給e
    *e = q->data;
    //讓系統回收此結點,釋放內存;
    free(q);
    
    return OK;
}

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

/* 初始條件：順序線性表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;
}

//3.1 單鏈表前插入法
/* 隨機產生n個元素值,建立帶表頭結點的單鏈線性表L(前插法)*/
void CreateListHead(LinkList *L, int n){
    
    LinkList p;
    
    //建立1個帶頭結點的單鏈表
    *L = (LinkList)malloc(sizeof(Node));
    (*L)->next = NULL;
    
    //循環前插入隨機數據
    for(int i = 0; i < n;i++)
    {
        //生成新結點
        p = (LinkList)malloc(sizeof(Node));
       
        //i賦值給新結點的data
        p->data = i;
        //p->next = 頭結點的L->next
        p->next = (*L)->next;
        
        //將結點P插入到頭結點之后;
        (*L)->next = p;
        
    }
}

//3.2 單鏈表后插入法
/* 隨機產生n個元素值,建立帶表頭結點的單鏈線性表L(后插法)*/
void CreateListTail(LinkList *L, int n,int data){
    
    LinkList p,r;
 
    //建立1個帶頭結點的單鏈表
    *L = (LinkList)malloc(sizeof(Node));
    //r指向尾部的結點
    r = *L;
    
    for (int i=0; i<n; i++) {
        
        //生成新結點
        p = (Node *)malloc(sizeof(Node));
        p->data = i+data;
        
        //將表尾終端結點的指針指向新結點
        r->next = p;
        //將當前的新結點定義為表尾終端結點
        r = p;
    }
    
    //將尾指針的next = null
    r->next = NULL;
    
}

//合并鏈表
Status MaxList(LinkList *L,LinkList *N){
    
    LinkList a,b;
    a = (*L)->next;
    b = *N;
    if (a == NULL || b == NULL) {
        return ERROR;
    }
    while (a&&a->next != NULL) {
        a= a->next;
    }
    a->next = b->next;
    free(b);
    return OK;
}

//相同合并
LinkList SameMaxList(LinkList L,LinkList N){
    
    LinkList ans;
    InitList(&ans);
    
    LinkList a,b,s,r;
    r = ans;
    a = (L)->next;
    b = (N)->next;
    if (a == NULL || b == NULL) {
        return ERROR;
    }
    
    for (;a;a = a->next) {
        int tmpdata = a->data;
        for (LinkList tmp = b;tmp;tmp = tmp->next) {
//            printf("%d ",tmp->data);
            if (tmpdata == (int)tmp->data) {
                s = (LinkList)malloc(sizeof(Node));
                s->data = tmpdata;
                s->next = NULL;
                r->next = s;
                r = s;
                break;
            }
        }
    }
    
    
    
    return ans;
}

Status exchangeList(LinkList *L){
    
    LinkList m,n;
    n = (*L)->next;
    (*L)->next = NULL;
    while (n) {
        m = n->next;
        n->next = (*L)->next;
        (*L)->next = n;
        n = m;
    }
    
    return OK;
}

Status DelTargetList(LinkList*L,int mink,int maxk){
    
    LinkList q,p;
    q = (*L);
    while (q&&q->next != NULL) {
        int tmp = q->next->data;
        if (maxk>=tmp&&tmp>=mink) {
            p = q->next;
            q->next = q->next->next;
            free(p);
        }else{
            q = q->next;
        }
    }
    return OK;
}


int main(int argc, const char * argv[]) {
    Status iStatus;
    LinkList L1,L2,L3;
//    struct Node *L2;
    
    //第一題
//    CreateListTail(&L1, 5,1);
//    printf("整理創建L的元素(后插法):\n");
//    ListTraverse(L1);
//    CreateListTail(&L2, 5,100);
//    printf("整理創建L的元素(后插法):\n");
//    ListTraverse(L2);
//    MaxList(&L1, &L2);
//    printf("合并表格:\n");
//    ListTraverse(L1);
    
    //第二題
//    CreateListTail(&L1,5,1);
//    ListTraverse(L1);
//    CreateListTail(&L2, 5,3);
//    ListTraverse(L2);
//    L3 = SameMaxList(L1, L2);
//    printf("合并表格:\n");
//    ListTraverse(L3);
    
    //第三題
//    CreateListTail(&L1,5,1);
//    ListTraverse(L1);
//    exchangeList(&L1);
//    printf("順序調轉:\n");
//    ListTraverse(L1);
    
    //第四題
    CreateListTail(&L1,5,1);
    ListTraverse(L1);
    DelTargetList(&L1, 3, 5);
    printf("刪除后:\n");
    ListTraverse(L1);
    
    
    
}