数据结构复习

最新推荐文章于 2024-09-11 14:37:20 发布

玩玩不是玩玩

最新推荐文章于 2024-09-11 14:37:20 发布

阅读量468

点赞数

文章标签：数据结构链表

本文链接：https://blog.csdn.net/weixin_65989620/article/details/127362872

版权

数据结构会吗？项目开发过程中主要用到些？

答：数据结构中主要会用到数组，链表，树（较少），也会用到栈和队列的思想。

链表的反转

一、通过头插法反转链表

 * struct ListNode {
 *  int val;
 *  struct ListNode *next;
 * };
 */

/**
 *
 * @param pHead ListNode类
 * @return ListNode类
 */
struct ListNode* ReverseList(struct ListNode* pHead )
// write code here
{
    if(pHead == NULL || pHead->next == NULL)
    return NULL;
    struct ListNode* p = NULL;
    struct ListNode* q = NULL;
    struct ListNode* l = pHead;
    p = l->next;
    l->next = NULL;
    while (p!=NULL) {
        q = p->next;
        p->next = l->next;
        l->next =  p;
        p = q;
    }
    return l;
}

合并两个有序链表

struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
class Solution {
  public:
    ListNode* Merge(ListNode* l1, ListNode* l2) 
	{
       
          struct  ListNode *res = new ListNode(0);
            struct ListNode *cur = res;
            while (l1 != NULL && l2 != NULL) {
                if (l1->val > l2->val) {
                    cur->next = l2;
                    l2 = l2->next;
                    cur = cur->next;
                } else {
                    cur->next = l1;
                    l1 = l1->next;
                    cur = cur->next;
                }
            }
            if (l1 == NULL) {
                cur ->next = l2;
            } else if (l2 == NULL) {
                cur ->next = l1;
            }
            return res;
    }
};

二叉树

迭代法
vector<int> preorder(vector<int>res,Treenode *root)
{
stack<Treenode *> st;
vector<int> result;
if(root == NULL)
return result;
st.push(root);
while(st-.empty())
{
Treenode *node =st.top();
st.pop()
result.push_back(node->val);
if(node->right)
st.push(node->right)
if(node->left)
st.push(node->left)
}
return result;
}
递归法二叉树前序遍历
void preorder (vector <int> &res ,Treenode *root )
{
if(root == NULL) return;
res.push_back(root -> val);
preorder(res,root->left)
preorder(res,root->right)
return;}
	vector<int> asdasdsdf(Tresnode *root)
{
vector<int> res;
preorder(res,root)
return res;
}

顺序表和链表的区别

1.数组空间固定，而链表的空间可以动态拓展。 2.数组是顺序存储的，而链表是链式存储 3.数组通过下标访问，访问便利，链表的访问需要遍历 4.数组的插入和删除需要移动数组内的元素，时间复杂度是o（n），链表在已知插入的位置时时间复杂度是o（1）比较便利 5.数组的存储一般是在栈区，而链表的存储一般是在堆区。

两个栈模拟一个队列

class Solution
{
public:
  void push(int node){
stack1.push(node);
}
int pop(){
if(stack2.empty()){
while(!stack1.empty()){
stack2.push(stack1.top());
stack1.pop();
}
}
int ans;
ans =stack2.top();
stack2.pop();
return ans;
}
  
private:
    stack<int> stack1;
    stack<int> stack2;
};

两个队列模拟一个栈

public:
void push(int data){
q1.offer(data);}
int  E pop()
{
E result = NULL
if(q1.size()>1)
{
q2.offer(q1.poll())
}
if(!q1.isEmpty)
{
result =q1.poll();
}
if(!q2.empty)
while(q2.size()>0)
{
q1.offer(q2.poll());
}
return result;
}

private：
deque q1;
deque q2;

快速排序

int search(int arr[],int i,int j)
{
int base =arr[i];
while(i<j){
while(i<j){
if(arr[j]<base){
break;}
j--;}
arr[i]=arr[j];
while(i<j){
if(arr[i]<base){
break;}
i++;}
arr[j]=arr[i];}
arr[i]=base;
return i;
}
void quiksort(int arr[] ,int i,int j)
{
int pos =search(arr[],i,j);
quiksort(arr, i,pos-1);
quiksort(arr,pos+1,j);
}

二分查找

int search(arr[],int low,int high,int key)
{
int mid=(low+high)/2;
while(low<=high)
{
if(mid>key)
{
high = mid-1;
}
if(mid<key)
{
low=mid+1;
}
if(mid == key)
{
return mid;
}
}
return -1;
}

啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦