数据结构

最新推荐文章于 2022-04-18 20:44:33 发布
最新推荐文章于 2022-04-18 20:44:33 发布
阅读量232 收藏
点赞数
分类专栏： 数据结构 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wyz6666/article/details/91050115
版权

数据结构部分

一. Array类的实现

#include <iostream>
#include <cassert>

template<typename T>
class Array{
private：
	T* data;
	int size;
	int capacity;
	void resize(int newCapacity){
		T* newData = new T[newCapacity];
		for(int i = 0; i < size; i++)
			newData[i] = data[i];
		data = newData;
		capacity = newCapacity;
	}
public:
	Array(int capacity){
		data = new T[capacity];
		size = 0;
		this->capacity = capacity;
	}
	Array(){
		data = new T[10];
		size = 0;
		capacity = 10;
	}
	~Array(){
		delete[] data;
	}
	int getCapacity(){
		return capacity;
	}
	int getSize(){
		return size;
	}
	bool isEmpty(){
		return size == 0;
	}
	void add(int index, T e){
		assert(index >=0 && index <= size);
		if(size == capacity)
			resize(2 * capacity);
		for(int i = size - 1; i >= index; i--)
			data[i + 1] = data[i];
		data[index] = e;
		size++;
	}
	void addFirst(T e){
		add(0, e);
	}
	void addLast(T e){
		add(size, e);
	}
	T get(int index){
		assert(index >= 0 && index < size);
		return data[index];
	}
	T getFirst(){
		return get(0);
	}
	T getLast(){
		return get(size - 1);
	}
	void set(int index, T e){
		assert(index >= 0 && index < size);
		data[index] = e;
	}
	bool contain(T e){
		for(int i = 0; i < size; i++)
			if(data[i] == e)
				return true;
		return false;
	}
	int find(T e){
		for(int i = 0; i < size; i++)
			if(data[i] == e)
				return i;
		return -1;
	}
	T remove(int index){
		assert(index >= 0 && index < size);
		T ret = data[index];
		for(int i = index; i < size - 1; i++)
			data[i] = data[i + 1];
		size--;
		if(size == capacity / 4 && capacity / 2 != 0)
			resize(capacity / 2);
		return ret;
	}
	T removeFirst(){
		return remove(0);
	}
	T removeLast(){
		return remove(size - 1);
	}
	void removeElement(T e){
		int index = find(e);
		if(index != -1)
			remove(index);
	}
}

二. Stack和Queue的实现

1. Stack

  • 接口类：Stack.h
template<typename T>
class Stack{
public:
	virtual int getSize() = 0;
	virtual bool isEmpty() = 0;
	virtual void push(T e) = 0;
	virtual void pop() = 0;
	virtual T front() = 0;
}
  • 实现类：ArrayStack.h
#include "Array.h"
#include "Stack.h"

template<typename T>
class ArrayStack : public Stack<T>{
private:
	Array<T>* array;
public:
	ArrayStack(int capacity){
		array = new Array<T>(capacity);
	}
	ArrayStack(){
		array = new Array<T>();
	}
	~ArrayStack(){
		delete[] array;
		array = nullptr;
	}
	int getSize() overide{
		return array->getSize();
	}
	bool isEmpty() overide{
		return array->isEmpty();
	}
	void push(T e) overide{
		array->addLast(e);
	}
	void pop() overide{
		array->removeLast();
	}
	T front() overide{
		return array->getLast();
	}	
}

2. Queue

  • 接口类：Queue.h
template<typename T>
class Queue{
public:
	virtual int getSize() = 0;
	virtual bool isEmpty() = 0;
	virtual void push(T e) = 0;
	virtual void pop() = 0;
	virtual T front() = 0;
}
  • 实现类：ArrayQueue.h（基于Array类）
#include "Array.h"
#include "Queue.h"

template<typename T>
class ArrayQueue : public Queue<T>{
private:
	Array<T>* array;
public:
	ArrayQueue(int capacity){
		array = new Array<T>(capacity);
	}
	ArrayQueue(){
		array = new Array<T>();
	}
	~ArrayQueue(){
		delete[] array;
		array = nullptr;
	}
	int getSize() overide{
		return array->getSize();
	}
	bool isEmpty() overide{
		return array->isEmpty();
	}
	void push(T e) overide{
		array->addLast(e);
	}
	void pop() overide{
		array->removeFirst();
	}
	T front() overide{
		return array->getFirst();
	}	
}
  • 实现类：LoopQueue.h（不基于Array类）
#include "Queue.h"

template<typename T>
class LoopQueue : public Queue<T>{
private:
	T* data;
	int front, tail;
	int capacity;
	void resize(int newCapacity){
		T* newData = new T[newCapacity]
		for(int i = 0; i < getSize(); i++)
			newData[i] = data[(i + front) % capacity];
		data = newData;
		front = 0;
		tail = getSize();
		capacity = newCapacity;
	}
public:
	LoopQueue(int capacity){
		data = new T[capacity];
		front = 0;
		tail = 0;
		this->capacity = capacity;
	}
	LoopQueue(){
		data = new T[10];
		front = 0;
		tail = 0;
		capacity = 10;
	}
	~LoopQueue(){
		delete[] data;
		array = nullptr;
	}
	int getSize() overide{
		return (tail + capacity - front) % capacity;
	}
	bool isEmpty() overide{
		return front == tail;
	}
	void push(T e) overide{
		if((tail + 1) % capacity == front)
			resize(2 * capacity);
		data[tail] = e;
		tail = (tail + 1) % capacity;
	}
	void pop() overide{
		assert(!isEmpty());
		front = (front + 1) % capacity;
		if(getSize() == capacity / 4 && capacity / 2 != 0)
			resize(capacity / 2);
	}
	T front() overide{
		assert(!isEmpty());
		return data[front];
	}	
}

三. LinkedList的实现

#include <iostream>

template<typename T>
class LinkedList{
private:
	struct Node{
		T e;
		Node* next;
		Node(T e, Node* next) : e(e), next(next){}
		Node(T e) : e(e), next(NULL){}
		Node() : next(NULL){}
	}
	Node* dummyHead;
	int size;
public:
	LinkedList(){
		dummyHead = new Node();
		size = 0;
	}
	~LinkedList(){
		while(dummyHead!= NULL){
			Node* node = dummyHead;
			dummyHead = dummyHead->next;
			delete node;
			size--;
		}
		assert(dummyHead== NULL && size == 0);
	}
	int size(){
		return size;
	}
	bool isEmpty(){
		return size == 0;
	}
	void insert(int index, T e){
		assert(index < 0 || index > size);
		Node* prev = dummyHead;
		for(int i = 0; i < index; i++)
			prev = prev ->next;	
		// 传统写法	
		//Node* insertNode = new Node(e);
		//insertNode->next = node->next;
		//node->next = insertNode;
		//炫酷写法
		prev->next = new Node(e, prev->next);
		size++;
	}
	void insertFirst(T e){
		insert(0, e);
	}
	void insertLast(T e){
		insert(size, e);
	}
	//获得链表的第index(0-based)个位置的元素
	T get(int index){
		assert(index < 0 || index >= size);
		Node curNode = dummyHead->next;
		for(int i = 0; i < index; i++)
			curNode = curNode->next;
		return curNode->e;
	}
	T getFirst(){
		return get(0);
	}
	T getLast(){
		return get(size - 1);
	}
	void set(int index, T e){
		assert(index < 0 || index >= size);
		Node* curNode = dummyHead->next;
		for(int i = 0; i < index; i++)
			curNode = curNode->next;
		curNode->e = e;
	}
	bool contain(T e){
		Node* curNode = dummyHead->next;
		while(curNode != NULL){
			if(curNode->e == e)
				return true;
			curNode = curNode->next;
		}
		return false;
	}
	void remove(int index){
		assert(index < 0 || index >= size);
		Node* prev = dummyHead;
		for(int i = 0; i < index; i++)
			prev = prev->next;
		Node* delNode = prev->next;
		prev->next = delNode->next;
		delete delNode;
		size--;
	}
	void removeFirst(){
		remove(0);
	}
	void removeLast(){
		remove(size - 1);
	}
	void removeElement(T e){
		Node* prev = dummyHead;
		while(prev->next != NULL){
			if(prev->next->e == e)
				break;
			prev = prev->next;
		}
		if(prev->next != NULL){
			Node* delNode = prev->next;
			prev->next = delNode->next;
			delete delNode;
			size--;
		}
	}
}

四. BST的实现

#include <iostream>
#include <queue>
#include <cassert>
using namespace std;

template<typename Key, typename Value>
class BST{
private:
	struct Node{
		Key key;
		Value value;
		Node* left;
		Node* right;
		Node(Key key, Value value){
			this->key = key;
			this->value = value;
			this->left = this->right = NULL;
		}
		Node(Node* node){
			this->key = node->key;
			this->value = node->value;
			this->left = node->left;
			this->right = node->right;
		}
	}
	Node* root; //根结点
	int count; //树中的结点个数
public:
	BST(){
		root = NULL;
		count = 0;
	}
	~BST(){
		destroy(root);
	}
	int size(){
		return count;
	}
	bool isEmpty(){
		return count == 0;
	}
	//向二分搜索树中插入一个新的(key, value)数据对
	void insert(Key key, Value value){
		root = insert(root, key, value);
	}
	bool contain(Key key){
		return contain(root, key);
	}
	//在二分搜索树中搜索key所对应的值。如果值不存在，则返回NULL
	Value* search(Key key){
		return search(root, key);
	}
	//二叉搜索树的前序遍历
	void preOrder(){
		preOrder(root);
	}
	//二叉搜索树的中序遍历
	void inOrder(){
		inOrder(root);
	}
	//二叉搜索树的后序遍历
	void postOrder(){
		postOrder(root);
	}
	//二叉搜索树的层次遍历
	void levelOrder(){
		if(root == NULL)
			return;
		queue<Node*> q;
		q.push(root);
		while(!q.empty()){
			Node* node = q.front();
			q.pop();
			cout << node->key;
			if(node->left)
				q.push(node->left);
			if(node->right)
				q.push(node->right);
		}
	}
	// 寻找二分搜索树最小的键值
	Key minimum(){
		assert(count != 0);
		Node* minNode = minimum(root);
		return minNode->key;
	}
	// 寻找二分搜索树最大的键值
	Key maximum(){
		assert(count != 0);
		Node* maxNode = maximum(root);
		return maxNode->key;
	}
	// 从二分搜索树中删除最小值所在的结点
	void removeMin(){
		if(root)
			root = removeMin(root);
	}
	// 从二分搜索树中删除最大值所在的结点
	void removeMax(){
		if(root)
			root = removeMax(root);
	}
	// 从二叉搜索树中删除键值为key的结点
	void remove(Key key){
		root = remove(root, key);
	}
private:
	//在以node为根的二叉搜索树中插入(key, value)数据对，并返回新的根
	Node* insert(Node* node, Key key, Value value){
		if(node == NULL){
			count++;
			return new Node(key, value);
		}
		if(key == node->key)
			node->value = value;
		else if(key < node->key)
			node->left = insert(node->left, key, value);
		else  //key > node->key
			node->right = insert(node->right, key, value);
		return node;
	}
	bool contain(Node* node, Key key){
		if(node == NULL)
			return false;
		if(key == node->key)
			return true;
		else if(key < node->key)
			return contain(node->left, key);
		else // key > node->key
			return contain(node->right, key);
	}
	Value* search(Node* node, Key key){
		if(node == NULL)
			return NULL;
		if(key == node->key)
			return &(node->value);
		else if(key < node->key)
			return search(node->left, key);
		else // key > node->key
			return search(node->right, key);
	}
	void preOrder(Node* node){
		if(node == NULL)
			return;
		cout << node->value;
		preOrder(node->left);
		preOrder(node->right);
	}
	void inOrder(Node* node){
		if(node == NULL)
			return;
		inOrder(node->left);
		cout << node->value;
		inOrder(node->right);
	}
	void postOrder(Node* node){
		if(node == NULL)
			return;
		postOrder(node->left);
		postOrder(node->right);
		cout << node->value;
	}
	//释放以node为根的二叉搜索树的所有结点
	void destroy(Node* node){
		if(node == NULL)
			return;
		destroy(node->left);
		destroy(node->right);
		delete node;
		count--;
	}
	Key minimum(Node* node){
		if(node->left == NULL)
			return node;
		return minimum(node->left);
	}
	Key maximum(Node* node){
		if(node->right == NULL)
			return node;
		return maximum(node->right);
	}
	Node* removeMin(Node* node){
		if(node->left == NULL){
			Node* rightNode = node->right;
			delete node;
			count--;
			return rightNode;
		}
		node->left = removeMin(node->left);
		return node;
	}
	Node* removeMax(Node* node){
		if(node->right == NULL){
			Node* leftNode = node->left;
			delete node;
			count--;
			return leftNode;
		}
		node->right = removeMax(node->right);
		return node;
	}
	Node* remove(Node* node){
		if(node == NULL)
			return NULL;
		if(key < node->key){
			node->left = remove(node->left);
			return node;
		}
		else if(key > node->key){
			node->right = remove(node->right);
			return node;
		}
		else { //key == node->key
			if(node->left == NULL){
				Node* rightNode = node->right;
				delete node;
				count--;
				return rightNode;
			}
			if(node->right == NULL){
				Node* leftNode = node->left;
				delete node;
				count--;
				return leftNode;
			}
			// node左右子树均不为空
			node* successor = new Node(minimum(node->right));
			count++;
			successor->right = removeMin(node->right);
			successor->left = node->left;
			delete node;
			count--;
			return successor;
		}
	}
}

五. maxHeap的实现

#include <iostream>
#include <cassert>
using namespace std;

template<typename Item>
class MaxHeap{
private:
	Item* data;
	int count;
public:
	// 构造函数, 构造一个空堆, 可容纳capacity个元素
	MaxHeap(int capacity){
		data = new Item[capacity + 1];
		count = 0;
	}
    // 构造函数, 通过一个给定数组创建一个最大堆(heapify)
    // 该构造堆的过程, 时间复杂度为O(n)
    MaxHeap(Item arr[], int n){
    	data = new Item[n + 1];
    	capacity = n;
    	for(int i = 0; i < n; i++)
    		data[i + 1] = arr[i];
    	count = n;
    	for(int i = parent(count); i >= 1; i--)
    		shiftDown(i);
    }
	~MaxHeap(){
		delete[] data;
	}
	int size(){
		return count;
	}
	bool isEmpty(){
		return count == 0;
	}
	void insert(Item item){
		assert(count + 1 <= capacity);
		data[count + 1] = item;
		shiftUp(count + 1);
		count++;
	}
	Item extractMax(){
		assert(count > 0);
		Item ret = data[1];
		swap(data[1], data[count]);
		count--;
		shiftDown(1);
		return ret;
	}
	Item getMax(){
		assert(count > 0);
		return data[1];
	}
private:
	void parent(int k){
		assert(k > 1);
		return k / 2;
	}
	void left(int k){
		return 2 * k;
	}
	void right(int k){
		return 2 * k + 1;
	}
	void shiftUp(int k){
		Item e = data[k];
		while(k > 1 && data[k] > data[parent(k)]){
			//swap(data[k], data[parent(k)]);
			data[k] = data[parent(k)];
			k = parent(k);
		}
		data[k] = e;
	}
	void shiftDown(int k){
		Item e = data[k];
		while(left(k) <= count){
			int j = left(k);
			if(right(k) <= count && data[right(k)] > data[left(k)]) 
				j = right(k);
			if(data[k] >= data[j])
				break;
			//swap(data[k], data[j]);
			data[k] = data[j];
			k = j;
		}
		data[k] = e;
	}
}

六. UnionFind的实现

一共有五个版本的unionFind：quickFind，quickUnion，基于size的优化，基于rank的优化，基于路径压缩的优化（最终版）

version 1：quickFind

#include <iostream>
#include <cassert>
using namespace std;

class UnionFind1{
private:
	int* id; //第一个版本的unionFind本质就是一个数组
	int count; //数据个数
public:
	UnionFind1(int n){
		count = n;
		id = new int[n];
		for(int i = 0; i < n; i++)
			id[i] = [i];
	}
	~UnionFind1(){
		delete[] id;
	}
	int find(int p){
		assert(p >= 0 && p < count);
		return id[p];
	}
	bool isConnected(int p, int q){
		return find(p) == find(q);
	}
	void unionElements(int p, int q){
		int pID = find(p);
		int qID = find(q);
		if(pID == qID)
			return;
		for(int i = 0; i < count; i++)
			if(id[i] == pID)
				id[i] = qID;
	}
}

version 2：quickUnion

class UnionFind2{
private:
	//第二版的unionFind，使用一个数组构建一棵指向父结点的树
	int* parent; //parent[i]表示第i个元素所指向的父结点
	int count; //数据个数
public:
	UnionFind2(int n){
		count = n;
		parent = new int[n];
		for(int i = 0; i < n; i++)
			parent[i] = i;
	}
	~UnionFind2(){
		delete[] parent;
	}
    // 查找过程, 查找元素p所对应的集合编号. O(h)复杂度, h为树的高度
	int find(p){
		assert(p >= 0 && p < count);
		while(p != parent[p])
			p = parent[p];
		return p;
	}
	bool isConnected(int p, int q){
		return find(p) == find(q);
	}
	void unionElements(int p, int q){
		int pRoot = find(p);
		int qRoot = find(q);
		if(pRoot == qRoot)
			return;
		parent[pRoot] = qRoot;
	}
}

version 3：quickUnion + size优化

class UnionFind3{
private:
	int* parent;
	int* sz; //sz[i]表示以i为根的集合中元素个数
	int count;
public:
	UnionFind3(int n){
		count = n;
		parent = new int[n];
		sz = new int[n];
		for(int i = 0; i < n; i++){
			parent[i] = i;
			sz[i] = 1;
		}
	}
	~UnionFind3(){
		delete[] parent;
		delete[] sz;
	}
	int find(p){
		assert(p >= 0 && p < count);
		while(p != parent[p])
			p = parent[p];
		return p;
	}
	bool isConnected(int p, int q){	
		return find(p) == find(q);
	}
	void unionElements(int p, int q){
		int pRoot = find(p);
		int qRoot = find(q);
		if(pRoot == qRoot)
			return;
        // 根据两个元素所在树的元素个数不同判断合并方向
        // 将元素个数少的集合合并到元素个数多的集合上
		if(sz[pRoot] < sz[qRoot]){
			parent[pRoot] = qRoot;
			sz[qRoot] += sz[pRoot];
		}
		else { //sz[pRoot] >= sz[qRoot]
			parent[qRoot] = pRoot;
			sz[pRoot] += sz[qRoot];
		}
	}
}

version 4：quickUnion + rank优化

class UnionFind4{
private:
	int* parent;
	int* rank; //rank[i]表示以i为根的树的高度
	int count;
public:
	UnionFind4(int n){
		count = n;
		parent = new int[n];
		rank = new int[n];
		for(int i = 0; i < n; i++){
			parent[i] = i;
			rank[i] = 1;
		}
	}
	~UnionFind4(){
		delete[] parent;
		delete[] rank;
	}
	int find(p){
		assert(p >= 0 && p < count);
		while(p != parent[p])
			p = parent[p];
		return p;
	}
	bool isConnected(int p, int q){	
		return find(p) == find(q);
	}
	void unionElements(int p, int q){
		int pRoot = find(p);
		int qRoot = find(q);
		if(pRoot == qRoot)
			return;
        // 根据两个元素所在树的高度不同判断合并方向
        // 将高度低的集合合并到高度高的集合上
		if(rank[pRoot] < rank[qRoot])
			parent[pRoot] = qRoot;
		else if(rank[qRoot] < rank[pRoot])
			parent[qRoot] = pRoot;
		else{ // rank[pRoot] == rank[qRoot]
			parent[pRoot] = qRoot;
			rank[qRoot] += 1; //此时维护rank的值
		}
	}
}

version 5：quickUnion + rank优化 + 路径压缩

class UnionFind5{
private:
	int* parent;
	int* rank; //rank[i]表示以i为根的树的高度
	int count;
public:
	UnionFind5(int n){
		count = n;
		parent = new int[n];
		rank = new int[n];
		for(int i = 0; i < n; i++){
			parent[i] = i;
			rank[i] = 1;
		}
	}
	~UnionFind5(){
		delete[] parent;
		delete[] rank;
	}
	int find(p){
		assert(p >= 0 && p < count);
		while(p != parent[p]){
			parent[p] = parent[parent[p]]; // path compression 1
			p = parent[p];
		}
		return p;
        //if( p != parent[p] )   // path compression 2, 递归算法
        //    parent[p] = find( parent[p] );
        //return parent[p];
	}
	bool isConnected(int p, int q){	
		return find(p) == find(q);
	}
	void unionElements(int p, int q){
		int pRoot = find(p);
		int qRoot = find(q);
		if(pRoot == qRoot)
			return;
        // 根据两个元素所在树的高度不同判断合并方向
        // 将高度低的集合合并到高度高的集合上
		if(rank[pRoot] < rank[qRoot])
			parent[pRoot] = qRoot;
		else if(rank[qRoot] < rank[pRoot])
			parent[qRoot] = pRoot;
		else{ // rank[pRoot] == rank[qRoot]
			parent[pRoot] = qRoot;
			rank[qRoot] += 1; //此时维护rank的值
		}
	}
}

七. hashTable的实现

#include <iostream>
#include <map>

template<typename Key, typename Value>
class HashTable{
private:
	int M;
	int size;
	map<Key, Value>** hashTable;
	int hash(Key key){
		return (hashCode(key) & 0x7fffffff) % M;
	}
	int hashCode(Key key){
		std::hash<Key> key_hash;
		return key_hash(key);
	}
public:
	HashTable(int M){
		this->M = M;
		size = 0;
		hashTable = new map<Key, Value>*[M];
		for(int i = 0; i < M; i++)
			hashTable[i] = new map<Key, Value>();
	}
    HashTable() {
        this->M = 97;
        size = 0;
        hashTable = new map<Key, Value>*[M];
        for (int i = 0; i < M; ++i)
            hashTable[i] = new map<Key, Value>();
    }
    int size(){
    	return size;
    }
    void insert(Key key, Value value){
    	map<Key, Value>* mp = hashTable[hash(key)];
    	if(mp->find(key) != mp->end())
    		mp[key] = value;
    	else{
    		mp->insert(key, value);
    		size++;
    	}
    }
    void remove(Key key){
    	map<Key, Value>* mp = hashTable[hash(key)];
    	if(mp->find(key) != mp->end()){
    		mp.erase(key);
    		size--;
    	}
    }
    void set(Key key, Value value){
    	map<Key, Value>* mp = hashTable[hash(key)];
    	assert(mp->find(key) != mp->end());
    	mp[key] = value;	
    }
    bool contain(Key key){
    	map<Key, Value>* mp = hashTable[hash(key)];
    	return mp->find(key) != mp->end() ? true : false;
    }
    Value get(Key key){
    	map<Key, Value>* mp = hashTable[hash(key)];
    	assert(mp->find(key) != mp->end());
    	return mp[key];
    }
}
【数据结构】线性表
love_guanghui的博客
04-21 631
一，线性表 1.基本概念 a.定义：线性表是具有相同数据类型的n个数据元素的有限序列***，其中n位表长，当n=0是线性表是一个空表。 b.几个概念： ·ai是线性表中的“第i个”元素线性表中的位序（注意：位序从1开始，数组下标从0开始）。 ·a1是表头元素*；an是表尾元素。 ·除第一个元素外，每个元素有且仅有一个前驱；除最后一个元素外，每个元素有且仅有一个后继。 2.基本操作 InitList(&L):初始化表。构造一个空的线性表L，分配内存空间 DestroyList(&L):销毁操
【数据结构笔记】线性表-顺序表
m0_56100838的博客
11-10 595
#include <iostream> using namespace std; #define InitSize 10 typedef struct{ int *data; //指针指向顺序表第一个元素// int MaxSize; int length; //当前长度// }SqList; void InitList(SqList &L){ L.data=(int *)malloc(InitSize*sizeof(int)); //返回一个指向这片...
数据结构一顺序表
m0_60961911的博客
02-02 1626
数据结构 = 数据定义 + 数据操作 顺序表：一片连续存储的区域 结构定义： size：代表当前顺序表大小 length：当前一共存储了多少个元素 data_type：存储的元素类型 结构操作： 插入： 删除： 1、数据结构的定义： typedef struct Vector{ int *data; int size,length; }Vector; 将struct结构类型重新定义成vector数据类型 int * data:指针是地址。 数据一片连续的
C语言 二维数组
weixin_43656926的博客
06-19 300
输出矩阵： #include <stdio.h> void main(void) { int i; int j; int num1; int num2; int data[][4] = {{1,2,3,4}, {4,5,6,7}, {8,9,10,11}}; num1 = sizeof(data) / sizeof(data[0]); num2 = sizeof(data[0]) / sizeof(int); printf("num1 = %d\n",num1); printf("num2 =.
C语言 int data = "pocky";
ngany的博客
04-02 816
void main(void) { int data = "pocky"; int *s = "pocky"; printf("data is %d \n", data); printf("something in data is %s \n", data); printf("s real addr is %d \n", &s); printf("s point addr i...
C++数据结构课程设计大作业-员工管理系统(带完整报告）
03-22
在这个C++数据结构课程设计大作业中，学生构建了一个员工管理系统，这是一项综合性的实践项目，旨在提升对C++编程语言、数据结构以及文件操作的理解。这个系统可以在命令行环境下运行，适合在Linux环境中编译，同时...
青岛大学王卓数据结构与算法课程PPT截图
02-17
数据结构与算法是计算机科学中的核心课程，它们是理解和解决复杂计算问题的基础。青岛大学的王卓教授的这门课程，通过PPT的形式，深入浅出地讲解了这些关键概念。 首先，我们从"绪论"开始。绪论部分通常会介绍数据...
[详细完整版]数据结构.txt
07-11
线性数据结构部分： 一、填空题 1. 数据结构包括数据的逻辑结构、 数据的储存结构 和数据的运算三个方面。 2. 数据结构包括 逻辑结构 、数据的存储结构和数据的运算三个方面。 3. 在算法"正确"的前提下，评价算法...
严蔚敏数据结构C语言版本-可运行源码-完全C语言代码实现.zip
08-17
严蔚敏数据结构C语言版本_可运行源码_完全C语言代码实现 ----- 毕业设计，课程设计，项目源码均经过助教老师测试，运行无误，欢迎下载交流 ----- 下载后请首先打开README.md文件（如有），某些链接可能需要魔法打开...
湖南大学计算机考研数据结构866历年20年的左右真题
最新发布
07-18
湖南大学计算机考研数据结构866历年20年的左右真题，有部分回忆版
p[0] =(int*)&data是什么意思？, (int*)与(int)*的区别
EricHai的博客
04-15 864
(int*)与(int)*的区别 直接上代码： /** * 功能：测试 p[0] =(int*)&data, 与(int)*data的区别 */ void test_int_point() { //(int*)&a printf("=====================test (int*)&a===================\n"); int a = 15; int* p[3] = { NULL }; p[0] = (int*)&a
C语言指针偏移技巧（也是一个要注意的坑）
热门推荐
轮子初级玩家
08-27 3万+
在C语言中，每个地址实际上指向一个8bit的内存区，但如果某个内存区的地址使用一个明确的类型指针例如int*、long*来进行保 存，那么指针偏移时地址的偏移数以类型占的字节数为基本单位进行偏移，例如int *p变量+1的时候实际上跳过的是sizeof(int)的类型字节数的地址为单位进行跳跃——也就是跳跃4个地址，但如果是不确认类型的情况下使用void*来保存，则必须指定每次跳跃的准......
顺序表的定义，增删改查
liyulin90的博客
04-18 297
顺序表的特点 1）随机访问：即可在o（1）时间内找到第i个元素。 {data[i-1]} 2）存储密度高，每个结点只存储数据元素 3）拓展容量不方便 4）插入，删除不方便 一，顺序表的定义 1）静态分配内存空间 //静态分配数组（无法改变顺序表大小） #define MaxSize 10 typedef struct { int data[MaxSize]; int length; }SqlList; //顺序表的定义类型 //初始化一个顺序表 void InitLi...
实验一 线性表的顺序存储与实现_【自考】数据结构中的线性表，期末不挂科指南，第2篇
weixin_39674414的博客
11-23 231
线性表这篇博客写的是线性表相关的内容，包括如下部分，先看下有木有期待啥是线性表线性表的顺序存储线性表的基本运算在顺序表上的实现线性表的链式存储线性表的基本运算在单链表上的实现循环链表与双向循环链表Over，内容还蛮多的！~ ￣□￣｜｜，头大了...首先明确一个非常重要的点 线性表是一个线性结构，注意上篇博客提过线性结构是数据的逻辑结构中的一种基本概念线性表是由n(n≥0)个数据元素组成的有穷序列大...
void * data 数据类型参数解释
小伟锅的博客
03-22 5680
void * data  是一个无类型的指针参数，任意类型指针可以赋值给data，当data复制给其他类型时需要先指定数据类型。 代码示例：int add(void *a,void *b) { int c; c=*((int*)a)+*((int*)b); return c; }int _tmain(int argc, _TCHAR* argv[]) { int a=1,b=2; i
c语言 顺序表 有序表,顺序表(数据结构)
weixin_30619981的博客
05-24 835
本篇文章主要针对《数据结构》中的顺序表的增删查改以及一些常用算法进行详尽的代码描述。本代码使用c语言书写，并且通过测试。可以直接拷贝编译，在你的main函数中进行测试。#include #include #define MaxSize 50 //顺序表的表长#define InitSize 100 //顺序表的初始表长typedef struct {int data[MaxSize]; //顺...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值