設指標la指向單鏈表的首結點：編寫演算法，從表la中刪除第i個元素起共len個元素

/*****************************************************************************
*設指標la指向單鏈表的首結點：編寫演算法，從表la中刪除第i個元素起共len個元素*
******************************************************************************/
void delete_list(List_Node* la,int i,int len){
    List_Node* p = la;
    int i = 0;
    for(i = 0; i < i-2;i++){//這個for迴圈使得p指向待刪除的第一個元素的前驅
        if(p == NULL){
            return ;
        }
        p = p->next;
    }
    for(i = 0; i < len;i++){//刪除第i個元素起共len個元素
        if(p->next == NULL){//當前節點的下一個節點為空則說明已經刪到最後一個節點
            return ;
        }
        p->next = p->next->next;
    }
}
 

整數序列作為輸入資料，當輸入資料為0是表示輸入結束。編寫演算法，將資料按遞增順序用單鏈表存放，並列印該連結串列

/*********************************************************
*整數序列作為輸入資料，當輸入資料為0是表示輸入結束*****
*編寫演算法，將資料按遞增順序用單鏈表存放，並列印該連結串列**
***********************************************************/

List_Node* sort_list(int a[]){//a[]表示題目所給的整數序列
    List_Node* head;//連結串列頭指標
    head = (List_Node*)malloc(List_Node);
    head->next = NULL;
    List_Node* pre;
    List_Node* last;
    List_Node* temp;
    int i = 0;
    while(a[i] != 0){
        pre = head;
        last = head->next;
        while(last != NULL && x >= last->data){//一前一後兩個指標，尋找應該插入的位置
            pre = last;
            last = last->next;
        }
        temp = (List_Node*)malloc(sizeof(List_Node));
        temp->data = a[i];
        temp->next = last;
        pre->next = temp;
        i++;
    }
    temp = head->next;
    while(temp != NULL){//列印連結串列
        printf("%d",temp->data);
        temp = temp->next;
    }
}
 

假設線性表l用帶頭結點的單鏈表儲存，且至少有兩個結點，每個節點的資料域為整型值。編寫演算法以判斷該連結串列中每一個結點的值是否等於其後續兩個結點值之和，若滿足上述要求，返回1 並輸出最大值；否則，返回0並輸出最小值

/*********************************************************************************
*假設線性表l用帶頭結點的單鏈表儲存，且至少有兩個結點，每個節點的***************
*資料域為整型值。編寫演算法以判斷該連結串列中每一個結點的值是否等於其後**************
*續兩個結點值之和，若滿足上述要求，返回1 並輸出最大值；否則，返回0並輸出最小值*
************************************************************************************/

int judge_list(List_Node* head){
    List_Node* pre = head->next;
    List_Node* mid = pre->next;
    List_Node* last = mid->next;
    int MAX = pre->data + mid->data;
    int temp_sum = 0;
    while(last != NULL){
        temp_sum = mid->data + last->data;
        if(pre->data != temp_sum){
            return 0;
        }
        if(temp_sum > MAX){
            MAX = temp_sum;
        }
    }
    printf("%d",MAX);
    return 1;
}
 

寫出將迴圈單鏈表中節點x的直接前驅刪除的演算法（x為指標，且從x指向節點出發進行刪除）

/**************************************************************************************
*寫出將迴圈單鏈表中節點x的直接前驅刪除的演算法（x為指標，且從x指向節點出發進行刪除)*
***************************************************************************************/

void delete_f(List_Node* x){
    List_Node* p = x;
    List_Node* q;
    while(p->next != x){
        p = p->next;
    }
    q = p->next;
    p->next = s;
    delete q;
}

設單鏈表的表頭指標為h，節點結構有data個next兩個域構成，其中data域為字元型。編寫演算法，判斷該連結串列的前n個字元組成的是否為迴文，要求使用棧和佇列。（迴文是指正讀反讀均相同的字元序列，如abba和abdba均是迴文，但good不是迴文）

/**************************************************************************************
*設單鏈表的表頭指標為h，節點結構有data個next兩個域構成，其中data域為字元型。編寫演算法，
判斷該連結串列的前n個字元組成的是否為迴文，要求使用棧和佇列。（迴文是指正讀反讀均相同的字
符序列，如abba和abdba均是迴文，但good不是迴文）*
***************************************************************************************/

bool judge_list(List_Node* h,int n){//棧是先進後出、隊是先進先出，將前n個元素依次壓入棧和隊之
    //後，再依次彈出比較（棧彈出是原序列的從後到前、隊彈出是原序列的從前到後），恰好是前後依次對比
    List_Node* temp = h->next;
    stack<char> s;
    queue<char> q;
    int i = n;
    char stack_temp;//存從棧中彈出的元素
    char queue_temp;//存從隊中彈出的元素
    while(temp != NULL&&i != 0){//依次壓入棧和隊
        s.push(temp->data);
        q.push(temp->data);
        temp = temp->next;
        i -- ;
    }
    while(!s.empty() && !q.empty()){
        stack_temp = s.top();//取棧頂元素，並不彈出
        queue_temp = q.first();//取隊的第一個元素，並不彈出
        if(stack_temp != queue_temp){
            return false;
        }
        s.pop();//將棧頂第一個元素彈出
        q.pop();//將隊的第一個元素彈出
    }
    return true;
}

已知f為單鏈表的表頭指標，連結串列中儲存的都是整型資料，試設計演算法將此連結串列的節點按照遞增次序進行就地排序

已知l為沒有頭結點的單鏈表中第一個節點的指標，每個節點資料域存放一個字元，該字元可能是英文字母字元或數字字元或其他字元。編寫演算法構造三個以帶頭結點的單迴圈連結串列表示的線性表，使每個表中只含同一類字元（要求用最少的時間個最少的空間）

/**************************************************************************************
已知l為沒有頭結點的單鏈表中第一個節點的指標，每個節點資料域存放一個字元，該字元可能
是英文字母字元或數字字元或其他字元。編寫演算法構造三個以帶頭結點的單迴圈連結串列表示的線性
表，使每個表中只含同一類字元（要求用最少的時間個最少的空間）
***************************************************************************************/
void sort_list(List_Node * head,List_Node* english,List_Node* number,List_Node* other){
    //遍歷、分別按要求插入三個連結串列中，english表示英文、number表示數字、other表示其他字元
    List_Node* p = head;
    List_Node* temp_e = english;
    List_Node* temp_n = number;
    List_Node* temp_o = other;
    while(p != NULL){
        if((p->data >= 'a' && p->data <= 'z') || (p->data >= 'A' && p->data <= 'Z')){
            temp_e = p;
            temp_e = temp_e->next;
        }else if(p->data >= '0' && p->data <= '9'){
            temp_n = p;
            temp_n = temp_n->next;
        }else{
            temp_o = p;
            temp_o = temp_o->next;
        }
    }
}

設有一個正整數序列組成的有序單鏈表（按遞增次序有序，且允許有相等的正整數存在），試編寫能實現下列功能的演算法（要求用最少的時間和最小的空間）

1）確定在序列中比正整數x大的數有幾個（相同的數只計算一次，如序列{20，20,17，16,15,11,10,8,7,7,5,4}中比10打的數有5個）

int judge(List_Node* head,int x){
    if(head == NULL){//帶頭結點，即head的值域為空
        return;
    }
    List_Node* pre = head->next;
    List_Node* p = head->next->next;
    int num = 0;
    if(pre->data > x){
        num++;
    }
    while(p != NULL){//大於X且與前一個值不同
        if(p->data > x && pre->data != p->data){
            num++;
        }
        pre = p;
        p = p->next;
    }
    return num;
}

2）在單鏈表將比x小的數按遞減次序排列

3）將正整數x打的偶數從單鏈表中刪除

void delete_list(List_Node* head,int x){
    List_Node* p = head->next;
    List_Node* pre = head;
    List_Node* temp;
    while(p != NULL){
        if(p->data > x && p->data%2 == 0){
            temp = p;
            pre->next = p->next;
            p = pre->next;
            delete(temp);
        }else{
            pre = p;
            p = p->next;
        }
    }
}

設有一個有正整陣列成的無序（向後）單鏈表，編寫完成下列功能的演算法

1）找出最小值節點，且列印該數值

2）若該數值是奇數，則將其與直接後繼節點的數值交換

3）若反數值是偶數，則將其直接後繼節點刪除

void Find_ist(List_Node* head){
    int Min;
    List_Node* record = heea->next;
    if(head->next == NULL){
        return;
    }
    List_Node* p = head->next;
    Min = p->data;
    while(p != NULL){//找最小節點
        if(Min > p->data){
            Min = p->data;
            record = p;
        }
        p = p->next;
    }
    printf("最小節點的數值：%d",Min);
    if(Min%2 != 0){//奇數
        if(record->next != NULL){
            record->data = record->next->data;
            record->next->data = Min;
        }
    }else{//偶數
        if(record->next != NULL){
            List_Node* temp = record->next;
            record->next = record->next->next;
            delete(temp);
        }
    }
}