连续存储关于数组的算法演示

在代码中为了省事 我就直接用c++中的cout来输出 当然也可以使用printf();

下面代码中写了 初始化 插入 输出 排序 导致等操作   

关于交换程序 我就直接使用两数相异或来交换

接下来看代码即可 代码中有写适当的注释 另外提醒大家 关于看不懂的大家一定要画图来理解

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <iostream>
using namespace std;
typedef struct Array
{
	int* base;
	int len;
	int num;
} Array;

void init_arr(Array* A,int length);
bool append_arr(Array * A,int val);
bool delete_arr(Array* A, int pos, int *val);//用 *val 来获取删除的元素
bool insert(Array* A, int pos,int val); //牢记数组下标从0 开始
int get();
bool isempty(Array *A);
bool is_full(Array * A);
void sort_arr(Array* A);
void show_arr(Array * A);
void inversion(Array* A);
void test(Array* A);
//**************************
int main()
{
	Array A;
	int val;
	init_arr(&A,6);

	test(&A);
	cout << "插入前 " << endl;
	show_arr(&A);
	cout << "*********************************" << endl;
	cout << "插入后 " << endl;

	insert(&A, 2, 3);

	delete_arr(&A, 2, &val);
	cout << "val====" << val << endl;
	cout << "倒置后的数组" << endl;
	inversion( &A);
	show_arr(&A);
	cout << "倒置后经过排序的数组" << endl;
	sort_arr(&A);
	show_arr(&A);
	return 0;
}

//******************************
void test(Array * A)
{
	append_arr(A,1);
	append_arr(A, 2);
	append_arr(A, 3);
	append_arr(A, 4);
	//append_arr(A, 5);// 追加5次后 num 为5
	//append_arr(A, 6);
	//if (append_arr(A, 7))
	//{
	//	cout << "插入成功" << endl;
	//}
	已满
	//else
	//	cout << "插入失败" << endl;  
		
}
void init_arr(Array *A,int length)
{
	A->base = new int[6];//分配6个整型的空间
	if (A->base == NULL)
	{
		std::cout << "分配失败" << std::endl;
		exit(-1);
	}
	else
	{
		A->len = length; A->num = 0;
	}
	return ;
}
void show_arr(Array *A)
{
	if (isempty(A))
	{
		cout << "数组为空" << endl;
	}
	else
	{//遍历输出当前元素个数 len为总长度
		for (int i = 0; i < A->num; i++)
		{
			cout << A->base[i] << endl;
		}
		cout << "A->num=" << A->num << endl;

		cout << "len=" << A->len << endl;
	}
}
//******8
bool isempty(Array* A)
{
	if (A->num==0)
	{
		
		return true;
	}
	else
		return false;
}

bool is_full(Array* A)
{
	if (A->num == A->len)//和长度相等就满了
	{
		return true;
	}
	else
		return false;
}


bool append_arr(Array* A, int val)
{
	if (is_full(A))
	{
		
		return false;
	}
	else
	{
		A->base[A->num] = val;//刚开始数组元素下标为0  调用一次num+1 后面追加元素直接调用即可
		A->num++;
		return true;
	}
}


bool insert(Array* A, int pos, int val)
{
	if (is_full(A))
	{
		return false;
	}
	if (pos<1 || pos>A->num + 1) //如果A->num+1 就会产生间隔 由于数组是 连续存储的
		return false;
	//由于数组下标是从0开始的
	for (int i = A->num-1; i >= pos - 1; i--)
	{
		A->base[i + 1] = A->base[i];//往后移动 下标+1
	   //循环过后pos-1的位置就空出来了 	
	}
	A->base[pos - 1] = val;
	//插入后记得长度加1
	A->num++;
	return true;
}

//   1 2 3 4 5 假如说删除3这个元素
bool delete_arr(Array* A, int pos, int* val)//删除那个元素下标就从要从 删除后的哪一个元素开始算起
{
	if (isempty(A))
		return false;
	if (pos<1 || pos>A->num)
		return false;//删除只用删除特定的

	//删除前获取pos前的一个的元素 第二个位置的下标为 1 
	*val = A->base[pos - 1];
	for (int i = pos; i < A->num; i++)
	{
		A->base[i - 1] = A->base[i];//下标往前走
	}
	A->num--;
	return true;
}

void inversion(Array* A)//将数组倒置  思路：最大的下标和最小的下标交换
{
	int i = 0;
	int j = A->num-1;
	while (i <j)
	{
		//交换他们的下标

		A->base[i] = A->base[i] ^ A->base[j];
		A->base[j] = A->base[i] ^ A->base[j];
		A->base[i] = A->base[i] ^ A->base[j];//通过异或来交换
		i++;
		j--;
	}
	return;
}


void sort_arr(Array* A) //排序
{
	//for (int i = 0; i < A->num; i++)  //第一种排序
	//{
	//	for (int j = i + 1; j < A->num ; j++)
	//	{
	//		if (A->base[i]>A->base[j])
	//		{
	//			A->base[i] = A->base[i] ^ A->base[j];
	//			A->base[j] = A->base[i] ^ A->base[j];
	//			A->base[i] = A->base[i] ^ A->base[j];
	//		}
	//	}
	//}


	for (int i = 0; i < A->num-1; i++)  //第二种种排序
	{
		for (int j = 0; j < A->num-1-i; j++)
		{
			if (A->base[i] > A->base[j])
			{
				A->base[i] = A->base[i] ^ A->base[j];
				A->base[j] = A->base[i] ^ A->base[j];
				A->base[i] = A->base[i] ^ A->base[j];
			}
		}
	}


}