如何将指定的元素插入至数组中指定的位置？？

[kgbkiller]

如题～～

[OpenHero]

int a[10];
a[3] = 1;
???
是这个样吗？

[jsjjms]

很简单呀，最简单的方法就是用一个循环，先将数组空间加一，然后将指定位置后的元素全部向后

移动一个位置，将需要插入的数据插入。。。

[kgbkiller]

如何将已定义的数组空间改变呢？我是个新手　怎么设置指向数组空间的指针啊？要定义常量么？

还有能不能象改变数组的存储是不是链式的？可不可以只改变插入位置前后的元素指针指向新的元素，而不是逐个移动？

可以的给个简单的例程　谢谢了

[hjf1010]

数组名就是指向数组的指针,并且这个指针是不能改变的,即:定义 int buf[10],则buf就是指向这个数组第一个元素的指针,并且不能通过buf=buf+1这样的形式改变buf的指向.

要设置指向数组空间的指针很简单,定义int *ptr;ptr=buf;就可以了.并且ptr+1指向第二个数组元素,依次类推.用指针和数组下标可以随意指向任何数组元素.如buf[8], *(ptr+6)等,并不是只能顺序访问.

另外,数组是一块连续的内存空间,这和链表是两回事.
不知道这样解释符合楼主的意思吗?

[zh1369]

思路是---链表
a[n]，b,temp,index

temp=a[index-1];
a[index-1]=&b;
b=a[index-1];

插入！(结构自己设计)

[jsjjms]

int a[] = {....};

int *p = a;

p就指向 数组a的指针了。

[PMsg]

给你个模版 实现了链表中的元素添加 删除 等功能


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



template <typename datatype>
class Collection
{
public:
Collection();
virtual ~Collection();

bool Add(const datatype &value);
void Add(Collection<datatype> &c);
bool Delete(const datatype &value);
void Clear();
const datatype& operator [](const int &index);
const bool operator ==(Collection<datatype> &c);
Collection<datatype> & operator =(Collection<datatype> &c);
int GetSize();

void CombineIt(Collection<Combine> &collection, int n);
private:
void _combine(Collection<Combine> &collection, Combine &combined, int n, int index);
struct Element
{
Element() : next(0)
{
}
datatype value;
Element *next;
};

Element *head, *tail;
int size;
};

#endif // !defined(AFX_OLLECTION_H__800AF24D_61D8_4E97_B6A0_08BE4CFAB1ED__INCLUDED_)

template <typename datatype>
Collection<datatype>::Collection() : size(0), head(new Element), tail(head)
{
head->next = 0;
}

template <typename datatype>
Collection<datatype>::~Collection()
{
Clear();
delete head;
}

// 向集合添加一个元素
// 返回true表示成功添加，返回false表示未添加
template <typename datatype>
bool Collection<datatype>::Add(const datatype &value)
{
// 查找是否已经存在相同元素
/* for(Element *e = head->next; e != 0; e = e->next)
{
if(e->value == value)
{
return false;
}
} */
// 为新元素分配空间
tail->next = new Element;
if(tail->next == 0)
{
return false;
}
tail = tail->next;
tail->next = 0;
tail->value = value;
size ++;

return true;
}

template <typename datatype>
void Collection<datatype>::Add(Collection<datatype> &c)
{
int size = c.size;
for(int i = 0; i < size; i++)
{
Add(c[i]);
}
}

// 从集合中删除一个元素
// 返回true表示成功删除，返回false表示元素未找到
/*template <typename datatype>
bool Collection<datatype>::Delete(const datatype &value)
{
// 在集合中查找要删除的元素
for(Element *e = head; e->next != 0; e = e->next)
{
if(e->next->value == value)
{
// 如果要删除的是尾结点，则把尾指针前移一位
if(e->next == tail)
{
tail = e;
}
// 从元素链中去除结点
Element *temp = e->next;
e->next = temp->next;
delete temp;
size --;

return true;
}
}

return false;
}*/

// 清除集合中的所有元素
// 即需要释放链表每个结点的内存空间
// 头结点除外
template <typename datatype>
void Collection<datatype>::Clear()
{
Element *temp = 0;
for(Element *e = head->next; e != 0; e = temp)
{
temp = e->next;
delete e;
}
}

// 返回指定索引的元素
template <typename datatype>
const datatype& Collection<datatype>::operator [](const int &index)
{
// 判断索引是否超出范围
if(index >= size)
{
std::cerr << "Index out of range!" << std::endl;
exit(1);
}
// 查找元素
// 从头结点开始数，每次后移一个结点，数到第index为止
Element *e = head->next;
for(int i = 0; i < index; i++,e = e->next);

// 返回第index个值
return e->value;
}

// 判断两个集合是否相等（元素个数及每个元素相等）
// 运算符重载，使对象可以使用==来判断是否相等
// 以下运算符重载类似
template <typename datatype>
const bool Collection<datatype>::operator ==(Collection<datatype> &c)
{
int size1 = size;
int size2 = c.size;
if(size1 != size2)
{
return false;
}
if(size1 == 0)
{
return true;
}
bool exist;
// 在集合1中查找是否存在集合2中的元素
for(int i = 0; i < size1; i++)
{
exist = false;
for(int j = 0; j < size2; j++)
{
// 利用[]运算符重载直接查找元素
if((*this)[i] == c[j])
{
exist = true;
break;
}
}
// 有一个元素不存在即返回false
if(!exist)
{
return false;
}
}

return true;
}

template <typename datatype>
Collection<datatype> &Collection<datatype>::operator =(Collection<datatype> &c)
{
// 清除当前集合中所有元素
Clear();
// 复制新元素到当前集合
Add(c);
}

// 返回当前集合中的元素个数
template <typename datatype>
int Collection<datatype>::GetSize()
{
return size;
}

// 求一个集合的组合，结果放入collection中
template <typename datatype>
void Collection<datatype>::CombineIt(Collection<Combine> &collection, int n)
{
if(n > size)
{
std::cerr << "Invalid n!" << std::endl;
exit(1);
}
Combine combined(n);
_combine(collection, combined, n, -1);
}

template <typename datatype>
void Collection<datatype>::_combine(Collection<Combine> &collection, Combine &combined, int n, int index)
{
int dest = size - n;
if(n > 0)
{
for(int i = index + 1; i <= dest; i++)
{
combined.data[--n] = (*this)[i];
_combine(collection, combined, n++, i);
}
}
else
{
collection.Add(combined);
}
}

[luyanfei78]

数组在编译时必须确定所用的空间，所以在空间分配好以后再插入一个元素必会导致重新分配空间。一般的做法就是在堆内存中重新分配n+1个（假设数组原来长度是n）该类型数据的空间，然后把原数组拷贝过来，待到插入位置写入新元素。
　　如果是使用C++里的vector，则大可不必如此，因为vector提供了insert成员函数。调用方式如下：
iterator insert(
iterator _Where,
const Type& _Val
);
只须传入插入位置和插入值即可。上面有位朋友提供了list方案来解决，当然是好，但我就是不明白，放着STL里现成的list不用，自己来写，太不划算了吧。

[megaboy]

楼主应该用一个链表来实现，数组不利于移动、添加和删除，链表做这个很方便的。

数组利于随机访问。

[beyondtkl]

同意樓上。。。不過 各有合適的地方就就是

看你看重哪一方面了。

[jlkzzh]

1要防止叔祖益处
2选定位置数据后移

[kgbkiller]

windking21(暗淡) 我还是个新手刚开始学Ｃ＋＋看不太懂啊
我想问的是如何指向数组元素个数的指针，可不可以改变该指针的值改变数组的大小？

[hjf1010]

不可以直接通过修改指针的值来修改数组大小。
不过可以这样
int buf[10];
buf=(int *)realloc(buf,size*sizeof(int));

数组分配多大是在程序执行前就要确定的,超过这个范围问题是很严重的,可能出现意想不到的后果,
这是c中很有名的越界问题,也是c的弱点之一,他没有提供数组越界保护.