动态数组的实现（c和java）

动态数组的具体实现（c和java）

顺序表的实现笔记
2.2线性表的顺序存储

2.2.2顺序存储的实现
➢求顺序表容量
➢求顺序表长度
➢插入元素
➢删除元素
➢查找某个位置上的元素
➢清空表
➢销毁表

（冒泡排序中双层for循环间的关系）

c实现

using namespace std;

#include <stdio.h>
#include <malloc.h>
#include <iostream>


//定义了一个数据类型，该数据类型的名字叫做struct Arr，该数据类型的名字叫做struct Arr，
//该数据类型含有3个成员，分别是pBase，len，cnt
struct Arr {
	int *pBase; //存储的是一个数组的第一个元素的地址
	int len;	//数组的所能容纳的最大元素的个数
	int cnt;	//当前数组有效元素的个数

};

void init_arr(struct  Arr * pArr, int length);
bool append_arr(struct  Arr* pArr,int value);	//最加
bool insert_arr(struct  Arr* pArr, int pos,int value);//pos的值从1开始
bool delete_arr(struct  Arr* pArr, int pos, int * pVal);
bool arr_is_empty(struct  Arr * pArr);//判断数组是否为空

bool is_full(struct  Arr* pArr);//判断数组是否满了 
void sort_arr(struct  Arr *pArr);
void show_arr(struct  Arr *pArr);
void inversion_arr(struct  Arr * pArr);



void main() {
	struct  Arr arr;
	int val;
	init_arr(&arr,6);

	append_arr(&arr,2);
	append_arr(&arr, 8);
	append_arr(&arr, 4);
	append_arr(&arr, 2);
	/*append_arr(&arr, 1);
	append_arr(&arr, 9);*/

	show_arr(&arr);
	//insert_arr(&arr, 2, 10);
	//show_arr(&arr);
	
	//if (delete_arr(&arr, 1, &val)) {
	//	printf("删除成功！\n");
	//	printf("您删除的元素是：%d\n", val);
	//}
	//else  {
	//	printf("删除失败\n");
	//}

	
	//show_arr(&arr);

	sort_arr(&arr);
	show_arr(&arr);

	//if (append_arr(&arr, 10)) {
	//	printf("追加成功\n");
	//}
	//else {

	//	printf("追加失败\n");
	//}

	//show_arr(&arr);

	/*inversion_arr(&arr);
	show_arr(&arr);*/

	system("pause");
	
}



void init_arr(struct  Arr* pArr,int length) {
	
	pArr->pBase = (int *)malloc(sizeof(int)*length);
	

	if (NULL == pArr->pBase) {
		printf("动态内存分配失败\n");
		exit(-1);//终止整个程序
	}
	else  {
		printf("动态内存分配成功\n");
		pArr->len = length;
		pArr->cnt = 0;
	}

	//(*pArr).len = 20;
	/*pArr->len = 22;*/
	return;

}
//追加
bool append_arr(struct  Arr* pArr,int value) {


	if (is_full(pArr)) {
		return false;
	}
		//
	else {
		
		pArr->pBase[pArr->cnt] = value;
		pArr->cnt++;
		return true;
	}

	
}
bool insert_arr(struct  Arr* pArr, int pos, int value) {

	int i;
	if (is_full(pArr)) {
		return false;
	}

	if (pos<1 || pos>pArr->cnt+1) {
		return false;
	}

	for (i = pArr->cnt - 1; i >= pos - 1; --i) {
		//把后面的元素赋值给前面的元素实现后移的效果
		pArr->pBase[i + 1] = pArr->pBase[i];
	}

	//不满的情况下添加值
	pArr->pBase[pos - 1] = value;
	(pArr->cnt)++;
	return true;
	
}
bool delete_arr(struct  Arr* pArr, int pos, int * pVal) {
	int i;
	if (arr_is_empty(pArr)) {
		return false;
	}
	else if (pos<1 || pos>pArr->cnt) {
		return false;
	}
	else {
		//把等待删除的元素赋给 *pVal
		*pVal = pArr->pBase[pos-1];
		for (i = pos; i < pArr->cnt; ++i) {
			pArr->pBase[i - 1] = pArr->pBase[i];

		}
		(pArr->cnt)--;
		return true;

	}



}


bool is_full(struct  Arr* pArr) {
	//有效个数等于长度
	if (pArr->cnt == pArr->len) 
		return true;
	
	else
		return false;
	
}

bool arr_is_empty(struct  Arr * pArr) {
	if (pArr->cnt == 0)
		return true;

	else
		return false;

}
//冒泡排序
void sort_arr(struct  Arr * pArr) {

	int i, j, temp;
	//第一种
	for (i = 0; i < pArr->cnt-1; i++) {
		for (j = 0; j < pArr->cnt - 1 - i;j++) {
			
			if (pArr->pBase[j]>pArr->pBase[j+1])
			{
				temp = pArr->pBase[j];
				pArr->pBase[j] = pArr->pBase[j + 1];
				pArr->pBase[j + 1] = temp;
			}
			
		
		}
	}


	//第二种
	//for (i = 0; i < pArr->cnt; i++) {
	//	for (j = i+1; j < pArr->cnt; j++) {

	//		if (pArr->pBase[i]>pArr->pBase[j]) {
	//			temp = pArr->pBase[i];
	//			pArr->pBase[i] = pArr->pBase[j ];
	//			pArr->pBase[j] = temp;
	//		}
	//	}
	//}


}
void show_arr(struct  Arr * pArr) {
	if (arr_is_empty(pArr)) {
		printf("数组为空！\n");
	}
	else {
		for (int i = 0; i < pArr->cnt; ++i) {
			printf("%d ", pArr->pBase[i]);
		}
		printf("\n");
	}

}


//元素倒置
void inversion_arr(struct  Arr * pArr) {
	int i = 0;
	int j = pArr->cnt - 1;
	int t;


	while (i < j) {
		t = pArr->pBase[i];
		pArr->pBase[i] = pArr->pBase[j];
		pArr->pBase[j] = t;
		++i;
		--j;
	}
	return;
}

java实现

import java.util.Arrays;

public class MyArray {

    //用于储存数据的数组
    private int[] elements;


    public MyArray() {
        elements = new int[0];
    }

    //获取数组长度
    public int size() {
        return elements.length;
    }

    //往数组的末尾添加一个元素
    public void add(int element) {
        //创建一个新数组
        int[] newArr = new int[elements.length + 1];

        //把原来的数组中的元素复制到新数组中
        for (int i = 0; i < elements.length; i++) {
            newArr[i] = elements[i];
        }

        //把添加的元素放入到新数组中
        newArr[elements.length] = element;

        //新数组替换旧数组
        elements = newArr;

    }

    //打印所有元素到控制台
    public void show() {

        System.out.println(Arrays.toString(elements));

    }


    //删除数组中的元素
    public void delete(int index) {
        //判断下标是否越界
        if (index < 0 || index > elements.length - 1) {
            throw new RuntimeException("下标异常");
        }

        //创建一个新的新的数组，长度为原数组的长度-1
        int[] newArr = new int[elements.length - 1];

        //复制原有数据到新数组
        for (int i = 0; i < newArr.length; i++) {
            //想要删除的元素前面的元素
            if (i < index) {
                newArr[i] = elements[i];
            } else {
                newArr[i] = elements[i + 1];
            }

        }
        //新数组替换旧数组
        elements = newArr;

    }


    //取出指定位置的元素
    public  int get(int index){
        return elements[index];
    }

    //插入元素到指定位置
    public void insert(int index,int element){

        //创建一个新的新的数组，长度为原数组的长度-1
        int[] newArr = new int[elements.length - 1];

        //复制原有数据到新数组
        for (int i = 0; i < newArr.length; i++) {
            //想要删除的元素前面的元素
            if (i < index) {
                newArr[i] = elements[i];
            } else {
                newArr[i+1] = elements[i];
            }

        }
        //插入元素
        newArr[index] =element;
        //新数组替换旧数组
        elements = newArr;

    }



}

public class TestMyArray {


    public static void main(String[] args) {
        MyArray ma = new MyArray();
        System.out.println(ma.size());

        ma.add(19);
        System.out.println(ma.size());


        ma.show();

    }
}