笔试面试常考编程题

//链表反转
//1.将2-n节点依次放到1节点后面，1再放到链表尾
//2.将2-n节点依次放到首节点前面
//3.直接变链表指向 这里采用3

//链表反转
//1.将2-n节点依次放到1节点后面，1再放到链表尾
//2.将2-n节点依次放到首节点前面
//3.直接变链表指向 这里采用3 
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

struct node{
    int value;
    struct node *next;
}; 

node* CreateNewNode(int value)
{
    node *p = new node();
    p->value =  value;
    p->next = NULL;
    return p;
}

void AddNewNode(node *p, int value)
{
    node *q = new node();
    q->value = value;
    q->next = NULL;
    while (p->next != NULL)
        p = p->next;
    p->next = q;
}

node* ReverseNode(node *head)
{
    node *p1, *p2, *p3;
    if (head == NULL || head->next == NULL) 
        return head;
    p1 = head;
    p2 = p1->next;
    while (p2)
    {
        p3 = p2->next;
        p2->next = p1;
        p1 = p2;
        p2 = p3;
    }
    head->next = NULL; //head is tail 
    return p1;
}

void PrintNode(node *head)
{
    if (head == NULL || head->next == NULL) 
        return;
    printf("%d",head->value);
    node *p;
    while (head->next != NULL)
    {
        p = head->next;
        printf("->%d", p->value);
        head = p;
    }
}

int main()
{
    int n, value;
    scanf("%d", &n);
    scanf("%d", &value);
    node *p = CreateNewNode(value);
    for (int i = 2; i <= n; i ++)
    {
        scanf("%d", &value);
        AddNewNode(p, value);
    }
    
    node *q = ReverseNode(p);
    PrintNode(q);
}

//二叉树三种遍历的非递归实现
//前序遍历 根左右
//中序遍历 左根右
//后续遍历 左右根

//二叉树三种遍历的非递归实现
//前序遍历 根左右 
//中序遍历 左根右 
//后续遍历 左右根
#include<stdio.h>
#include<string.h>
#include<stack>
#include<algorithm>
using namespace std;
struct node{
    char data;
    struct node *lchild;
    struct node *rchild; 
};
stack<node*>st;

void createTree(node *&T)
{
    char ch;
    scanf("%c", &ch);
//    printf("%c",ch);
    if (ch == ' ') T = NULL;
    else 
    {
        T = (node*)malloc(sizeof(node));
        T->data = ch;
        createTree(T->lchild);
        createTree(T->rchild);
    }
}

void preOrder(node *T)
{
    while (!st.empty()) st.pop();
    node *p;
    p = T;
    while (p != NULL || !st.empty())
    {
        while (p != NULL)
        {
            printf("%c ", p->data);
            st.push(p);
            p = p->lchild;
        }
        if (!st.empty())
        {
            p = st.top();
            st.pop();
            p = p->rchild; 
        }
    }
    printf("\n"); 
}

void midOrder(node *T)
{
    while (!st.empty()) st.pop();
    node *p;
    p = T;
    while (p != NULL || !st.empty())
    {
        while (p != NULL)
        {
            st.push(p);
            p = p->lchild;
        }
        if (!st.empty())
        {
            p = st.top();
            st.pop();
            printf("%c ", p->data);//与前序遍历差别在于先遍历输出完左边 
            p = p->rchild; 
        }
    }
    printf("\n");         
}

int main()
{
    node *T;
    createTree(T);
    preOrder(T);
    midOrder(T);
    return 0;
} 
//sample ABD   CE  F   

//快排 以左基准数拿出跳跃插空

//快排 以左基准数拿出跳跃插空
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;

void msort(int a[], int l, int r)
{
    if (l >= r) return;
    int key = a[l];
    int low = l, high = r;
    while (low < high)
    {
        while (low < high && a[high] > key) high--;
        a[low] = a[high];
        while (low < high && a[low] < key) low++;
        a[high] = a[low];
    }
    a[low] = key;
    msort(a, l, low - 1);
    msort(a, low + 1, r);
}

int a[100005];
int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
        scanf("%d", &a[i]);
    msort(a, 1, n);
    for (int i = 1; i <= n; i++)
        printf("%d ", a[i]);
    printf("\n");
}