C语言链表复习

C语言链表复习

---

使用C语言实现链表及其基本功能，每种功能实现都使用了迭代写法和与其对应的一种或多种递归写法

---

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

#define count 0
#define max_f(a, b) (a > b)? a : b
#define min_f(a, b) (a < b)? a : b

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

typedef struct Node *link;
typedef link list;

void print (list p)  // 打印链表中所有数据
{
    while (p!=NULL) {
        printf("%d  ", p->data);
        p=p->next;
    }
    putchar ('\n');
}

list create (char *s)  // 创建一个链表
{
    link cur;
    list res;
    if (*s=='\0') return NULL;
    res=cur=(link) malloc (sizeof (node));
    cur->data = *s - '0';
    s++;
    while (*s!='\0') {
        cur=cur->next=(list) malloc(sizeof (node));
        cur->data=*s - '0';
        s++;
    }
    cur->next = NULL;
    return res;
}

/*链表的创建
1，-双头节点创建- 创建两个相同头节点指针，并动态malloc分配一个地址给其一，操作其中一个头节点，返回的另一个头节点即为所要的链表。
2，-头节点预处理-  因为已经提前创建了头节点，所以在进入下一步(循环)前，处理好头节点（赋值，next）
3，-循环-，处理节点（开辟内存，赋值）
4，-封尾- 尾节点加上p -> next = NULL;*/

int sum_1(list p){  // 迭代 求链表所有数据的和
    link t = p;
    int sum_all = 0;
    while(t != NULL){
        sum_all  +=  t -> data;
        t = t -> next;
    }
    return sum_all;
}

int sum_2(list p){ // 递归 求链表中所有元素的和
	if(p -> next == NULL)
	return p -> data;
	else
	return sum_2(p -> next) + p -> data;
}

int max_1(list p){  // 迭代 求链表中的最大值
    link t = p;
    int M = t -> data;
    while(t != NULL){
        if(t -> data > M)
            M = t -> data;
        t = t -> next;
    }
    return M;
}

 int max_2(list p)   //递归一 求链表中元素的最大值
 {
   	if (p -> next == NULL)
   		return p -> data;
 	else
 		return max_f(max_2(p -> next), p -> data);
 }

int max_3(list p)   //递归二 求链表中元素的最大值
{
	if(p -> next == NULL)
		return p -> data;
	else
	{
		if(max_3(p -> next) >  p -> data)
			return max_3(p -> next);
		else
			return p -> data;
	 }
}

int max_4(list p)  //递归三 求链表中元素的最大值
{
    int maxval;
    if (p -> next == NULL)
    {
        return p -> data;
    }
    else
    {
         maxval = max_4(p -> next);
         if (maxval < p -> data)
            maxval = p -> data;
         return maxval;
    }
}

int order_1(list p)  // 迭代 判断链表是否有序
{
    if (p == NULL)
        return 0;
    int flag;
    while (p -> next != NULL)
    {
        if (p -> data < p -> next -> data)
            flag = 1;
        else{flag =0; break;}
        p = p -> next;
    }
    if (flag == 1)
        return 1;
    else
        return 0;
}


int order_2(list p)   // 递归一 判断链表是否有序
{
 	if (p -> next == NULL)
  		return p -> data;
	else
	{
		if(p -> data < order_2(p -> next))
			return p -> data;
		else
			return 0;
	}
}

int order_3(list p) // 递归二  判断链表是否有序
{
    list pre;
    if(p == NULL) // 若可以遍历到末尾，则必定满足
        return 1;
    else
    {
        pre = p;   
        if (pre != NULL  &&  pre -> data > p  -> next-> data) return 0;
        order_2(p -> next);  // 不一定可以叠起来
    }

}

int add_minmax_1(list p) // 迭代 求最大最小值之和
{
    list t = p;
    int min, max;
    min = max = t->data;
    while(t != NULL)
    {
        if (min > t -> data)
            min = t ->data;
        if (max < t -> data)
            max = t -> data;
        t = t -> next;
    }
    int res = min + max;
    return res;
}

// ---------------------------------------------------------------

int max_f2(list p)   //求表中元素的最大值
 {
   	if (p -> next == NULL)
   		return p -> data;
 	else
 		return max_f(max_f2(p -> next), p -> data);
 }

 int min_f2(list p)   // 求表中元素最小值
 {
   	if (p -> next == NULL)
   		return p -> data;
 	else
 		return min_f(min_f2(p -> next), p -> data);
 }

int add_minmax_2(list p) // 强行递归了
{
    int maxval = max_f2(p);
    int minval = min_f2(p);

    return maxval + minval;
}

 // ---------------------------------------------------------------

void chance_1(list p)  // 迭代 交换链头链尾
{
    list t = p;
    while(t -> next != NULL)
        t = t -> next;
    int tmp = t -> data;
    t -> data = p -> data;
    p -> data = tmp;
}

void chance_2(list p, list p_start)  // 递归 交换链头链尾
{
    // 用递归将链表指向链尾
    if(p -> next == NULL)
    {
        int tmp = p_start -> data;
        p_start -> data = p -> data;
        p -> data = tmp;
    }
    else
        chance_2(p -> next, p_start);
}

void twosame(list p)  //迭代 判断链表中是否有两个相同的数
{
    int flag = 0;
    list t = p;
    list l = t;
    int val;
    while(p != NULL)
    {
        list l = t;
        val = p -> data;
        while (l != NULL)
        {
            if(val == l -> data){
                flag++;
                l = l -> next;
            }
            else
                l = l -> next;
        }
        p = p -> next;
    }
    if(flag >= 2)
        printf("yes\n");
    else
        printf("no");
}


int twosame_2(list p, list p_start)  //递归 判断链表中是否有两个相同的数
{
    int sum = 0;
    if(p_start -> next == NULL)
        return sum;

    if(p -> next == NULL)
        sum = twosame_2(p_start -> next, p_start -> next);
    else if(p_start -> data != p -> next -> data)
        sum = twosame_2(p -> next , p_start);
    else if(p_start -> data == p -> next -> data)
        sum = 1 + twosame_2(p -> next, p_start);
    return sum;

}