数据结构 之 链表、树

链表

typedef struct LNode
{
	int data;
	struct LNode* next;
}LNode;
LNode* p = (LNode)malloc(sizeof(LNode));
p->next=NULL;
//c++
class LNode
{
public:
	int data;
	LNode* next;
};
LNode* p = new LNode;
//静态链表,下标代表地址，数组值代表data
typedef struct
{
	int data;
	int next;
}LNode;
LNode nodes[MaxSize];

链表操作

//头插法
void headInsert(LNode* head, int data)
{
	//头节点为空结点
	LNode* p= new LNode;
	p->data=data;
	p->next=head->next;
	head->next=p;
}
//尾插法
void tailInsert(LNode* head, int data)
{
	LNode* p;
	p=head;
	while(p)
		p=p->next;
	LNode* p1=new LNode;
	p1->data=data;
	p1->next=nullptr;
	p->next=p1;
}

二叉树

 typedef struct BTNode
{
	int data;
	struct BTNode* LChild;
	struct BTNode* RChild;
}BTNode;
//先序遍历
void preorder(BTNode *p) {
    if (p != nullptr) {  // 一定要记得判空
        cout << p->data;
        preorder(p->lchild);
        preorder(p->rchild);
    }
}
//中序遍历
void inorder(BTNode *p) {
    if (p != nullptr) {
        inorder(p->lchild);
        cout << p->data;
        inorder(p->rchild);
    }
}
//后续遍历
void postorder(BTNode *p) {
    if (p != nullptr) {
        postorder(p->lchild);
        postorder(p->rchild);
        cout << p->data;
    }
}
//层次遍历
//#include<queue>
void level(BTNode* root)
{
    queue<BTNode*> q; //存地址会更节省空间
    if(root)
    {
    	q.push(root);
        while(!q.empty())
        {
            BTNode* p=q.front();
            cout << p->data << " ";
            q.pop();
            if(p->LChild)
                q.push(p->LChild);
            if(p->RChild)
                q.push(p->RChild);
        }
        cout << "end" << endl;
    }
}

树

typrdef struct 
{
    char data;
    int children[maxSize];
    int n;//孩子的数量
}TNode;
TNode nodes[maxSize];

排序二叉树

排序二叉树，建树的时候，先查找插入的位置，且都是插入在叶子结点。
删除结点时，从要删除的结点处，往右扫描一个结点，然后往左扫描，直到为空。将要替换的结点和最后扫描结束时的结点，交换位置后，删除要删除的结点，这样不会破坏排序二叉树的结构。

vector<int> a;
void insert(Node*& root, int a)//将a插在二叉排序数合适的位置
{
	if (root == nullptr)//找到待插入结点，进行插入操作
		root = new Node(a);
	else//递归查找待插入位置
	{
		if (a < root->value)
			insert(root->left, a);
		else
			insert(root->right, a);
	}
}
Node* creatRoot(int point)//创建一棵二叉排序数
{
	Node* root = nullptr;
	for (int i = 0; i < a.size(); i++)
	{
		insert(root, a[i]);
	}
	return root;
}

平衡二叉树

它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
####### PAT 1066

#include<iostream>
using namespace std;
typedef struct BTNode
{
    int data;
    struct BTNode *lChild,*rChild;
}BTNode;
BTNode *rotateL(BTNode *root)//左旋
{
    BTNode *t=root->rChild;
    root->rChild=t->lChild;
    t->lChild=root;
    return t;
}
BTNode *rotateR(BTNode *root)//右旋
{
    BTNode *t=root->lChild;
    root->lChild=t->rChild;
    t->rChild=root;
    return t;
}
BTNode *rotateLR(BTNode *root)//左右型
{
    root->lChild=rotateL(root->rChild);
    return rotateR(root);
}
BTNode *rotateRL(BTNode *root)//右左型
{
    root->rChild=rotateR(root->rChild);
    return rotateL(root);
}
int getHeight(BTNode *root)
{
    if(root==nullptr)
        return 0;
    return max(getHeight(root->lChild),getHeight(root->rChild))+1;
}
void insert(BTNode *&root, int data)//边建树，边调整
{
    if(root==nullptr)
    {
        root=new BTNode();
        root->data=data;
        root->lChild=root->rChild=nullptr;
    }
    else if(data < root->data)
    {
        insert(root->lChild,data);
        if(getHeight(root->lChild)-getHeight(root->rChild)==2)//左边高
            root=data < root->lChild->data?rotateR(root):rotateLR(root);//重点来了
    }
    else
    {
        insert(root->rChild,data);
        if((getHeight(root->lChild)-getHeight(root->rChild)==-2)//右边高
            root=data > root->rChild->data?rotateL(root):rotateRL(root);//重点来了
    }
}
int main()
{
    int N,data;
    cin >> N;
    BTNode *root = nullptr;
    for(int i=0;i<N;i++)
    {
        cin >> data;
        insert(root,data);
    }
    cout << root->data;
    return 0;
}