PAT 数据结构

1.1 最大子列和问题

# include "stdio.h"
#include "stdlib.h"
int main(){
    int num,max = 0;
    scanf("%d",&num);
    int *arr;
    arr = malloc(sizeof (int)*num);
    for(int i = 0;i<num;i++)
        scanf("%d",&arr[i]);

    for (int i =0;i<num;i++){
        int sum = 0;
        for (int j = i; j<num;j++){
                sum = sum+arr[j];
                if (sum>max) max = sum;
        }
    }
    printf("%d",max);
}

1.8 二分查找

Position BinarySearch( List L, ElementType X ){
    int pletf = 0;
    int s = 1;
    int e = L->Last;
    int num = e/2;
    while(num--){
        int mid = (s + e) / 2;
        if(L->Data[mid] == X){
            p = mid;
            break;
        }else if(L->Data[e] == X){
            p = e;
            break;
        }else if(L->Data[mid] > X){
            e = mid;
        }else if(L->Data[mid] < X){
            s = mid;
        }

    }
    if(p == 0)
        return NotFound;
    return p;
}

1.9 有序数组的插入

// 法一 直接遍历 找到 L->Data[i] < X < L->Data[i]+1
// 法二 二分查找 找到对应数组index

bool Insert( List L, ElementType X )
{
	int left = 0,right = L->Last,mid;
	if(L->Last==MAXSIZE-1) return false;// 表满，无法插入
    
    while (left <= right) {
        mid = (left + right) / 2;
        if (L->Data[mid] > X) {
            left = mid + 1;
        }
        else if (L->Data[mid] < X) {
            right = mid - 1;
        }
        else if(L->Data[mid] == X){
            return false; //表中已有该元素， 无法插入
        }
        
    } // left 为插入的位序
    
    for(int j = L->Last; j >= left; j-- ){
        L->Data[j+1] = L->Data[j];
    }
    L->Data[left] = X;
    L->Last ++;
    return true;
} 

2.4 递增的整数序列链表的插入

List Insert( List L, ElementType X ){
    List tmp, pre;
    pre = L;
    
    // 循环到最后一个链表(下一个为空，跳出循环)
    while(pre->Next){
        // 插入在中间
        if(pre->Data < X && X< (pre->Next)->Data) break;
         // 插入在第一位
        if(pre->Data >= X) break;
        pre = pre->Next;
    }
    
    // 链表插入操作
    tmp = (List)malloc(sizeof(struct Node));
    tmp->Data = X;
    tmp->Next = pre->Next;
    pre->Next = tmp;
    return L;
}

2.5 两个有序链表序列的合并

List Merge( List L1, List L2 ){
    List L3=(List)malloc(sizeof(List));
    List p1=L1,p2=L2,p3=L3;
    p1=p1->Next;
    p2=p2->Next;
    while(p1&&p2){
        if(p1->Data<p2->Data){
            p3->Next=p1;
            p3=p3->Next;
            p3 = p1;
            p1=p1->Next;
        }
        else{
            p3->Next=p2;
            p3=p3->Next;
            p3 = p2;
            p2=p2->Next;
        }
    }
    p3->Next=p1?p1:p2;
    L1->Next=NULL;
    L2->Next=NULL;
    return L3;
}

2.7 弹球距离

double dist( double h, double p ){
    double dis = 0; // 记录总路程
    if (h<TOL) return h; // 如果小于h,小球只弹一次
    while(h>=TOL){
        dis = dis+h;
        h = h*p;
        if(h>=TOL) dis = dis+h;
    }
    return dis;
}

3.3 线性表元素的区间删除

List Delete( List L, ElementType minD, ElementType maxD ){
    int i ,j= 0;
    int tmp[L->Last+1];
    for(int i=0;i<=L->Last;i++){
        if(L->Data[i] <= minD || L->Data[i]>= maxD)
            tmp[j++] = L->Data[i];
    }
    L->Last = j-1;
    for (int index = 0; index<=j;index++)
        L->Data[index] = tmp[index];
    return L;
}

3.5 求链表的倒数第m个元素

ElementType Find( List L, int m ){
    int i=0,cnt = 0;
    List p = L;
    p = p->Next;
    while(p!=NULL){
        p = p->Next;
        cnt++;
    }
    if(m>cnt || m<=0) return ERROR ;
    
    while(i<=cnt-m){
        L = L->Next;
        i++;
    }
    return L->Data;
}

3.12 另类循环队列

bool AddQ( Queue Q, ElementType X ){
    // 判断是否已满
    if(Q->Count > Q->MaxSize-1){
        printf("Queue Full\n");
        return ERROR; 
    }else{
        Q->Count ++;
        Q->Data[(Q->Front+Q->Count)%Q->MaxSize] = X;
        return true;
    }
}

ElementType DeleteQ( Queue Q ){
    // 判断是否为空
    if(Q->Count == 0){
        printf("Queue Empty\n");
        return ERROR ;
    }else{
        Q->Front = (Q->Front+1)%(Q->MaxSize);
        Q->Count --;
    }
    return Q->Data[Q->Front];    
}

3.14 另类堆栈

bool Push( Stack S, ElementType X ){
    // 判断栈是否已满
    if(S->MaxSize == S->Top){
        printf("Stack Full\n");
        return false;
    }
    // 插入
    S->Data[S->Top] = X;
    S->Top ++;
    return true;
}

ElementType Pop( Stack S ){
    // 判断堆栈是否为空
    if(S->Top == 0){
        printf("Stack Empty\n");
        return ERROR ;
    }else{
        int ans = S->Data[S->Top-1];
        S->Top--;
        return ans;
    } 
}