考研代码记录

void Enqueue(CircleNode* &circlelist,int data){
    CircleNode* r = circlelist;
    CircleNode* newNode = (CircleNode*)malloc(sizeof(CircleNode));
    newNode->data = data;
    newNode->next = r->next;
    r->next = newNode;
    
}

void Dequeue(CircleNode* &circlelist){
    CircleNode* r = circlelist;
    CircleNode* del = r->next;
    r->next = del->next;
    free(del);
}

//判断栈输入是否合法  iooo iooi
bool judgeInputStack(char input[]){
    int stack[10];
    int top = -1;
    //判断input和output数量是否一致
    //判断任何时刻input数量是否大于output
    int inputCount = 0;
    int outputCount = 0;
    for (int i = 0;input[i] != '\0'; ++i) {
        if (inputCount < outputCount) {
            printf("Error: i<o\n");
            return 0;
        }
        if (input[i] == 'i') {
            stack[++top] = 'i';
            inputCount++;
        }else if(input[i] == 'o'){
            top--;
            outputCount++;
        }else{
            printf("Error: input data is not valid.\n");
            return 0;
        }
    }
    if (top == -1) {
        printf("Successful!\n");
        return 1;
    }else{
        printf("Error: the count of 'i' and 'o' are different.");
        return 0;
    }
}

//reverse any position 12345
void reverse(int a[], int left, int right){
    int length = ( right - left + 1)/2;
    for (int i = 0; i< length; i++) {
        int temp;
        temp = a[left-1+i];
        a[left-1+i] = a[right-i-1];
        a[right-i-1] = temp;
    }
}

void circleReverse(int a[],int p,int length){
    reverse(a, 1, p);
    reverse(a, p+1,length);
    reverse(a, 1, length);
}

void outputPointer(NodePointer* head){
    NodePointer* ret = head->next;
    while (ret) {
        printf("%d,",ret->data);
        ret = ret->next;
    }
    printf("\n");
}

void diffList(NodePointer* &A,NodePointer* B){
    NodePointer* ahead = A->next;
    NodePointer* bhead = B->next;
    
    NodePointer* newPointer = (NodePointer*)malloc(sizeof(newPointer));
    newPointer->next = NULL;
    NodePointer* tail = newPointer;
    //尾指针减少时间成本，不用一直遍历到最后面
    
    while (ahead && bhead) {
        if (ahead->data == bhead->data) {
            bhead = bhead->next;
            ahead = ahead->next;
        }else{
            NodePointer* newk = (NodePointer*)malloc(sizeof(NodePointer));
            newk->data = ahead->data;
            tail->next = newk;
            tail = tail->next;
            ahead = ahead->next;
        }
    }
    tail->next = NULL;
    outputPointer(newPointer);
}

void difference(NodePointer* &A,NodePointer* B){
    NodePointer* atail = A->next;
    NodePointer* btail = B->next;
    NodePointer* pre = A;
    while (atail && btail) {
        if (atail->data < btail->data) {
            pre = atail;
            atail = atail->next;
        }else if(atail->data > btail->data){
            btail = btail->next;
        }else{
            pre->next = atail->next;
            atail = atail->next;
        }
    }
    outputPointer(A);
}

void deleteOrder(LNode &Node,int left,int right){
    int deleteindex = left-1;
    for (int i = right; i<Node.length; i++) {
        Node.data[deleteindex++] = Node.data[i];
    }
    Node.length = Node.length - (right-left+1);
}

void testdiff() {
NodePointer* a= (NodePointer*)malloc(sizeof(NodePointer));
NodePointer* ahead =a;
for (int i = 0; i< 5 ; i++) {
    NodePointer* p = (NodePointer*)malloc(sizeof(NodePointer));
    p->data = i;
    a->next = p;
    a = a->next;
}
a->next = NULL;
outputPointer(ahead);

NodePointer* b = (NodePointer*)malloc(sizeof(NodePointer));
NodePointer* bhead = b;
for (int i = 0; i< 5 ; i++) {
    NodePointer* p = (NodePointer*)malloc(sizeof(NodePointer));
    p->data = i*4;
    b->next = p;
    b = b->next;
}
b->next = NULL;
outputPointer(bhead);

difference(ahead, bhead);
}

void resort(LNode &node){
    //21346708
    int temp = node.data[0];
    int left = 0;
    int right = node.length-1;
    while (left<right) {
        while (left<right && node.data[right]>temp) {
            right--;
        }
        if (left<right) {
            node.data[left] = node.data[right];
            left++;
        }

        while (left<right && node.data[left]<temp) {
            left++;
        }
        if (left<right) {
            node.data[right] = node.data[left];
            right--;
        }
    }
    node.data[left] = temp;
}

void quickSort(LNode &L){
    LNode node;
    node.data[0] = 2;
    node.data[1] = 1;
    node.data[2] = -7;
    node.data[3] = -3;
    node.data[4] = 5;
    node.data[5] = 6;
    node.data[6] = -1;
    node.length = MaxSize;

    
    int i = 0;
    int j = L.length-1;
    int head = L.data[0];
    while (i<j) {
        while(i<j && L.data[j]>head) {
            j--;
        }
        if (i<j) {
            L.data[i] = L.data[j];
            i++;
        }
       
        while (i<j && L.data[i]<head) {
            i++;
        }
        if (i<j) {
            L.data[j] = L.data[i];
            j--;
        }
    }
    L.data[i] = head;
}

//删除递增序列重复节点
void deleteRedundant(NodePointer* &L){
    NodePointer* head = L->next;
    while (head) {
        NodePointer* temp = head->next;
        if (temp && temp->data == head->data) {
            head->next = temp->next;
            free(temp);
        }else{
            head = head->next;
        }
    }
}

void deleteMin(NodePointer* &L){
    NodePointer* p = L->next;
    int temp = p->data;
    int count = 0;
    int minIndex = count;
    while (p) {
        if (p->data < temp) {
            temp = p->data;
            minIndex = count;
        }
        p = p->next;
        count++;
    }
    
    NodePointer* k = L->next;
    if (minIndex == 0) {
        NodePointer* deleteNode = k->next;
        k->next = deleteNode->next;
        free(deleteNode);
        return;
    }
    
    count = 0;
    while (k) {
        if (count == minIndex-1) {
            NodePointer* deleteNode = k->next;
            k->next = deleteNode->next;
            free(deleteNode);
            break;
        }
        count++;
        k = k->next;
    }
}

void deleteMinbyPre(NodePointer* &L){
    NodePointer* head = L->next;
    NodePointer* pre = L;
    NodePointer* followhead = L;
    int min = head==NULL?0:head->data;
    while (head) {
        if (head->data < min) {
            min = head->data;
            pre = followhead;
        }
        else{
            followhead = head;
        }
        head = head->next;

    }
    NodePointer* deletePoint = pre->next;
    pre->next = deletePoint->next;
    free(deletePoint);
}

void outputData(LNode node){
    for (int i = 0; i<node.length; i++) {
        printf("%d,",node.data[i]);
    }
    printf("\n");
}

//头插法实现逆序！！经典
void reverselist(NodePointer* &L){
    NodePointer* p = L->next;
    L->next = NULL;
    NodePointer* q;
    while (p) {
        q = p->next;
        p->next = L->next;
        L->next = p;
        p = q;
    }
}

//实现奇数和偶数序列
void splitList(NodePointer* &L){
    NodePointer* aHead = L->next;
    
    NodePointer* b = (NodePointer*)malloc(sizeof(NodePointer));
    b->next = NULL;
    NodePointer* Bhead = b;
    
    NodePointer* a = (NodePointer*)malloc(sizeof(NodePointer));
    a->next = NULL;
    NodePointer* Ahead = a;
    
    while (aHead) {
        if (aHead->data%2 == 0) {
            Bhead->next = aHead;
            Bhead = Bhead->next;
        }else{
            Ahead->next = aHead;
            Ahead = Ahead->next;
        }
        aHead = aHead->next;
    }
    Bhead->next = NULL;
    Ahead->next = NULL;
    
    outputPointer(a);
    outputPointer(b);
}

void split(NodePointer* &L){
    NodePointer* aHead = L->next;
    NodePointer* aHeadPre = L;
    
    NodePointer* b = (NodePointer*)malloc(sizeof(NodePointer));
    b->next = NULL;
    NodePointer* Bhead = b;
    
    while (aHead) {
        if (aHead->data%2==0) {
            Bhead->next = aHead;
            Bhead = Bhead->next;
            aHeadPre->next = aHead->next;
            aHead = aHeadPre->next;
            
        }else{
            aHeadPre = aHead;
            aHead = aHead->next;
        }
    }
}

int findknode(NodePointer* L,int k){
    NodePointer* head = L->next;
    NodePointer* findk = L->next;
    int count = 0;
    while (head) {
        count++;
        head = head->next;
    }
    if (count>=k) {
        int seqCount = count-k;
        while (seqCount>0) {
            findk = findk->next;
            seqCount--;
        }
        printf("k= %d,data = %d\n",k,findk->data);
        return 1;
    }else{
        return 0;
    }
}

void pointerExample() {
    NodePointer* pointer = (NodePointer*)malloc(sizeof(NodePointer));
    NodePointer* L = pointer;
    //newnode->next = h-> next;
    //h->next = newnode;
    for (int i = 0; i<1; i++) {
        NodePointer* newNode = (NodePointer*)malloc(sizeof(NodePointer));
        newNode->data = 1;
        L->next = newNode;
        L = L->next;
    }
    for (int i = 0; i<1; i++) {
        NodePointer* newNode = (NodePointer*)malloc(sizeof(NodePointer));
        newNode->data = 10;
        L->next = newNode;
        L = L->next;
    }
    for (int i = 0; i<1; i++) {
        NodePointer* newNode = (NodePointer*)malloc(sizeof(NodePointer));
        newNode->data = 3;
        L->next = newNode;
        L = L->next;
    }
    for (int i = 0; i<1; i++) {
        NodePointer* newNode = (NodePointer*)malloc(sizeof(NodePointer));
        newNode->data = 4;
        L->next = newNode;
        L = L->next;
    }
    L->next = NULL;
    outputPointer(pointer);
    findknode(pointer, 5);
}

void judgeBracket(char a[],int n){
    Stack stack;
    stack.top = -1;
    for (int i = 0; i < n; i++) {
        if (a[i] == '(') {
            stack.data[++stack.top] = a[i];
        }
        if (a[i] == ')') {
            if (stack.top!=-1) {
                --stack.top;
            }else{
                printf("Error NULL\n");
                return;
            }
        }
    }
    if (stack.top != -1) {
        printf("Error\n");
    }else{
        printf("Success\n");
    }
}

void generate(int left,int right,int n,string s,vector<string> &list){
    if (left == n && right == n) {
        cout<<s<<"\n";
        list.push_back(s);
        return;
    }
    
    if (left < n) {
        generate(left+1,right,n,s+"(",list);
    }
    
    if (left > right) {
        generate(left,right+1,n,s+")",list);
    }
}

vector<string> generateParenthesis(int n) {
    vector<string> list;
    generate(0,0,n,"",list);
    return list;
}

void hanoiTemp(int n, string source, string temp, string target){
    ///        hanoiTemp(2, source, target, temp); 递归入口
    ///        hanoiTemp(1, source, temp, target); 步骤四
    ///        hanoiTemp(2, temp, source, target); 回到起点！

    ///        hanoiTemp(1, source, temp, target); 步骤一
    ///        hanoiTemp(1, source, target, temp); 步骤二
    ///        hanoiTemp(1, target, source, temp); 步骤三
    if (n == 1) {
        cout<<source<<"->"<<target<<"\n";
    }else{
        printf("语句1:%d\n",n-1);
        hanoiTemp(n-1, source, target, temp);
        
        printf("语句2:搬第%d层\n",n);
        hanoiTemp(1,source,temp,target);

        printf("语句3:%d\n",n-1);
        hanoiTemp(n-1, temp, source, target);
    }
}

//求二叉树深度
int Deepth(BTNode* treeNode){
    //recursion terminator
    if (treeNode == NULL) {
        return 0;
    }
    int left =  Deepth(treeNode->left);
    int right = Deepth(treeNode->right);
    return left>right?left+1:right+1;
}

void findNode(BTNode* node,int key,BTNode* q){
    if (node) {
        return;
    }
    if (node->data == key) {
        q = node;
        return;
    }
    findNode(node->left, key,q);
    if(q){
        findNode(node->right, key,q);
    }
}