链表遍历、查找，递归快速排序、递归取最小值

#include <stdio.h>

struct student{
    long num;
    float score;
    struct student *next; // 属性名是next,*next指针变量。
};

/**
 *     链表循环遍历
 */
void studentDemo1(){
    struct student a,b,c,*p; // 属性名是p,*p指针变量。
    a.num=100;a.score=89.5;
    b.num=101;b.score=88;
    c.num=102;c.score=87;
    p=&a; // a地址赋值对象p，即对象p指向a的地址
    a.next=&b;
    b.next=&c;
    c.next=NULL;

    do {
        printf("%ld %5.lf\n", p->num, p->score);
        printf("%ld\n", (*p).num);
        p=p->next;
    } while (p != NULL);
}

/**
 *    链表查找下一个
 *    stu：起始元素
 *    k：查找的位置
 */
struct student* Find_Student(struct student *stu, int k){
    struct student *p; int i;
    i=1; p=stu; // 指向当前地址
    while(p&&i<k){
        p=p->next;
        i++;
    }
    if(p&&i==k) return p;
    return NULL;
}

void runFindStudent(){
    struct student a,b,c;
    a.num=100;a.score=89.5;
    b.num=101;b.score=88;
    c.num=102;c.score=87;
    a.next=&b;
    b.next=&c;
    c.next=NULL;

    struct student *item = Find_Student(&a, 4);
    if(item != NULL){
        printf("%ld", item->num);
    }else{
        printf("无元素");
    }
}

/**
 * a[] 排序数组
 * n 数组长度
 */
void quicksort(int a[], int n){
    int i,j;
    int pviot = a[0];
    i=0; j = n-1;
    while(i<j){
        while(i<j && a[j] >= pviot) j--; // 右侧大于基准值j--，不换位置
        if(i<j) {
            // a[j]<pviot，交换位置
            a[i]=a[j]; // 右侧小于基准值的元素，放在左侧
            i++; // 基准值左侧的下一个
        }
        while(i<j && a[i]<=pviot) i++; // 左侧小于基准值i++,不换位置
        if(i<j){
            // a[i]>pviot，交换位置
            a[j]=a[i]; // 左侧小于基准值的元素，放在右侧
            j--; // 基准值右侧的前一个
        }
    }
    a[i]=pviot;
    if(i>1) quicksort(a, i); // 递归，对基准值左侧进行排序
    if(n-i-1>1) quicksort(a+i+1, n-i-1); //    递归，对基准值右侧进行排序
}

void runQuickSort(){
    int i, arr[]={23,56,9,75,18,42,11,67};
    int length;
    length = sizeof(arr)/sizeof(int);
    quicksort(arr, length);
    for(i=0; i<length; i++){
        printf("%d\t", arr[i]);
    }
}

int main() {
    runQuickSort();
}

 

递归取最小值：

#include <stdio.h>
#include <assert.h>

int minOne2(int arr[], int k){
    printf("k：%d\n", k);
    int t;
    assert(k>0);
    if(k==1) return arr[0];
    t=minOne2(arr+1, k-1); // k-1和--k都行
    if(arr[0]<t){
        return arr[0];
    }
    return t;
}

int main() {
    int arr[8]={48,2321,433,61,3,4,5,6};
    printf("arr 第一个元素：%d\n", arr[0]);
    printf("arr 个数：%d\n", sizeof(arr)/sizeof(int));
    printf("arr+1 第一个元素：%d\n", (arr+1)[6]);
    printf("arr+1 字节数：%d\n", sizeof(arr+1));
    int result=0,k=8;
    result = minOne2(arr, k);
    printf("k：%d\n", k);
    printf("最小数：%d\n", result);
}

 递归判断字符是否存在在字符串中

#include <stdio.h>

int is_elem(char ch, char *set){
    if(*set=='\0') {
        return 0;
    }else{
        if(*set==ch){
            return 1;
        }else{
            return is_elem(ch, set+1);
        }
    }
}

void runIsElem(){
    char str[30] = "hello, I am lh";
    int isExist = is_elem('z', str);
    printf("%d", isExist);
}

int main(int argc, char **argv) {
    runIsElem();
}